Weight-Space Programming (Gewichtsraum-Programmierung)

Gewichtsraum-Programmierung

Verbessere ein kleines offenes Modell hinsichtlich eines Ziels, indem du seine Gewichte direkt bearbeitest, ohne einen Optimierer. Dies folgt Experiment 8 von „Sparks of Weight-Space Programming“ (Takehi, Teoh, Zhang, Khattab, MIT CSAIL, 2. Nov. 2026): Die Denkschleifen von Qwen3.5-0.8B wurden auf eine residuelle Richtung zurückgeführt, die von den MLPs der Schichten 15 und 19 geschrieben wurde, und eine Rang-1-Bearbeitung von 64 down_proj-Spalten pro Schicht erhöhte MATH-500 von 7,9 % auf 48,1 %.

Befolge den schnellen Pfad unten in der Reihenfolge. Jedes Skript ist in scripts/ gebündelt und getestet. Baue die Pipeline nicht neu und schreibe keine neuen Werkzeuge, es sei denn, ein Schritt schlägt fehl.

Was die Fähigkeit garantiert und was nicht. Keine Methode kann versprechen, dass eine Bearbeitung hilft: Manche Modelle haben keine einzelne Gewohnheit, die sich abschalten lässt. Die Fähigkeit garantiert stattdessen den Prozess:

• kein Arbeitsverlust: Abstürze starten mit einem kleineren Batch neu und setzen fort;
• keine Bearbeitung erreicht den zurückgehaltenen Test, ohne eine gemessene Übungsprüfung bestanden zu haben;
• ein fehlgeschlagener Test eskaliert über festgelegte Schritte, anstatt anzuhalten;
• jeder Durchlauf endet mit einem klaren Ergebnis und Zahlen, und die Kopie wird wiederhergestellt, wenn nichts funktioniert.

Referenzen, nur für Details:

• references/goals.md: andere Ziele; wie man passende Paare schreibt; Bewerter; Rezepte.
• references/engines.md: welche Engine auf welchem Betriebssystem und GPU, Installation, Dimensionierung, Fallstricke, Rauchtest.
• references/evaluation.md: Aufteilungen, Stichprobenprotokoll, MMLU-Pro-Spezifika, gepaarte Statistiken, Berichtsvorlage.
• references/method.md: die Mathematik jedes Schrittes und das genaue Rezept der Autoren.

Schneller Pfad

Setze vier Platzhalter einmalig (PowerShell: $env:SKILL = "...", dann $env:SKILL):

SKILL=<dieser Faehigkeitenordner>  BASE=<Basis-Modellordner>  COPY=<Basis-Modellordner>-<Ziel>  WORK=<Ergebnisordner>

Führe jeden Generierungsjob im Hintergrund aus (Claude Code: das run_in_background des Bash-Tools, nicht ein Shell &) und warte auf seine Fertigstellungsmeldung anstatt zu pollend. Die Generierung dominiert die Zeit, also teile dem Benutzer das Budget im Voraus mit: 1,5–3 Stunden auf einer Verbraucher-GPU für die Voreinstellungen, viel weniger mit vLLM auf einer Rechenzentrums-GPU.

0. Frage nur, was du brauchst (eine Frage). Frage nach dem Ziel. Wenn es Mathematik oder Naturwissenschaften ist, verwende die Voreinstellung: keine weiteren Fragen. Andernfalls frage auch oder hilf beim Schreiben von:

• Prompts, die den Fehler zeigen, als {"id", "prompt", "answer"?, "group"?} JSON-Zeilen;
• wie man sie bewertet (references/goals.md Abschnitt 3);
• für Nicht-Schleifen-Verhalten, 12+ passende Paare (Abschnitt 2).

Bestätige „Gewichte bearbeiten, kein Training“.

1. Überprüfe die Maschine (2 Min): python $SKILL/scripts/device.py --model $BASE --jobs 2. Auf einer neuen Maschine führe auch den Rauchtest in references/engines.md Abschnitt 6 durch.

2. Kopiere das Modell (1 Min). Jede Bearbeitung geht in die Dateien dieser Kopie; jede Auswertung lädt die Kopie.

python $SKILL/scripts/copy_model.py --base $BASE --copy $COPY

3. Aufteilungen (Sekunden).

• Naturwissenschaften-Voreinstellung: python $SKILL/scripts/make_splits.py --task mmlu --source <MMLU-Pro-Test-Parquet> --out $WORK/splits.
• Mathematik-Voreinstellung: das Gleiche mit --task math --source <MATH-500-test.jsonl> --practice 25 --heldout 75.
• Eigenes Ziel: Teile deine Prompt-Datei in practice.jsonl und heldout.jsonl durch eine feste Regel auf, plus eine test_ids.txt mit etwa 30 zurückgehaltenen IDs, alle ausgewählt, bevor eine Antwort gesehen wird.

Unten ist T die Aufgabe (mmlu, math oder jsonl) und G die Bewerteroptionen (keine für die Voreinstellungen; siehe sonst references/goals.md).

4. Starte zwei Basis-Durchläufe gleichzeitig:

python $SKILL/scripts/run_eval.py --task $T --model $BASE --label base --data $WORK/splits/practice.jsonl --out $WORK/practice/base.jsonl --max-tokens 16384 --jobs 2

python $SKILL/scripts/run_eval.py --task $T --model $BASE --label base --data $WORK/splits/heldout.jsonl --ids-file $WORK/splits/test_ids.txt --out $WORK/test/base.jsonl --jobs 2

Verwende die Sampling-Parameter der Modellkarte für andere Modelle (--profile, oder die Überschreibungsflags; references/engines.md). Der zurückgehaltene Durchlauf hängt nicht von der Bearbeitung ab.

5. Erhalte den Kontrast.

• Schleifen (Voreinstellungen oder jedes Ziel, bei dem Antworten die Grenze erreichen): Schleifen treten nur auf, wenn eine Antwort die Grenze erreicht. Zähle sie mit grep -c '"length"' $WORK/practice/base.jsonl; bei 15 oder mehr, beende den Übungsdurchlauf.
• Andere Verhaltensweisen: Du brauchst die Paare, und der Übungsdurchlauf muss nur zu Ende gehen, um die Grundlinie zu liefern.

Dann bewerte:

python $SKILL/scripts/grade.py --task $T $G $WORK/practice/base.jsonl --out $WORK/practice/summary.json

Go/No-Go. Schätze den Spielraum für Verbesserung: der Anteil der Antworten, die das Verhalten zeigen, multipliziert mit der Punktzahl der Antworten, die es nicht zeigen. Liegt er unter etwa 10 %, teile dem Benutzer mit, dass wenig zu erwarten ist, bevor du fortfährst.

6. Lies die Richtung aus, baue Kandidaten, überprüfe (Minuten, nur Vorwärtsdurchläufe). Schleifen:

python $SKILL/scripts/probe.py collect --task $T --model $BASE --data $WORK/splits/practice.jsonl --runs $WORK/practice/base.jsonl --out $WORK/probes

Paare (füge --runs, --data und --task für saubere Seiteneffektfenster hinzu):

python $SKILL/scripts/probe.py collect-pairs --model $BASE --pairs pairs.jsonl --thinking on --out $WORK/probes

Dann baue die Kandidaten der ersten Runde, die Kontrolle und überprüfe:

for spec in "15 19:128:6" "15 19:256:6" "15 19:64:6" "11 15 17 19 21:128:6"; do IFS=: read L K A <<< "$spec"; python $SKILL/scripts/probe.py build --probes $WORK/probes --model $BASE --layers $L --k $K --alpha $A --out "$WORK/edits/L${L// /-}_k${K}_a${A}.safetensors"; done

python $SKILL/scripts/probe.py build --probes $WORK/probes --model $BASE --layers 15 19 --k 128 --alpha 6 --control random --out $WORK/edits/random.safetensors

python $SKILL/scripts/probe.py screen --probes $WORK/probes --model $BASE --edits $WORK/edits/*.safetensors

Unter Windows PowerShell führe jede build-Zeile einzeln aus. Die obigen Schichten passen für ein 24-Schichten-Modell. Verwende für andere die Schichten bei etwa 60 % und 80 % der Tiefe, eine Fünf-Schichten-Spanne und die tiefere allein.

Ordne die Kandidaten nach dem Rückgang bei unwanted, behalte nur diejenigen, deren Rückgänge bei wanted und clean unter einem Drittel davon liegen. Die Zufallskontrolle muss nahe 0 bleiben; bewegt sie sich so stark wie der beste Kandidat, ist die Richtung nicht spezifisch, also gehe zum Stopp-Schritt.

7. Schreibe den besten Kandidaten in die Kopie und überprüfe (1 Min). Werte niemals eine Bearbeitung im Speicher aus.

python $SKILL/scripts/apply_edit.py --base $BASE --copy $COPY --edit $WORK/edits/<Kandidat>.safetensors

python $SKILL/scripts/diff_edit.py --base $BASE --edited $COPY --out $WORK/edit_report.json

Der Diff darf nur die beabsichtigten down_proj-Tensoren zeigen, changed_columns = k, einen Rang-1-Anteil von etwa 1 und einen medianen α von etwa dem gewählten α.

8. Übungsprüfung: das Tor (15–25 Min, neben dem zurückgehaltenen Basislauf). Führe die Kopie auf jeder Übungsfrage aus, die die Basis nicht bestanden hat (abgeschnitten, falsch oder markiert), plus 6, die sie gut gelöst hat:

python -c "import json; g=json.load(open('$WORK/practice/summary.json'))['graded']['base']; bad=[x['id'] for x in g if x['cut'] or x['correct'] is False or x['flagged']]; ok=[x['id'] for x in g if x['id'] not in bad]; open('$WORK/check_ids.txt','w').write('\n'.join(bad+ok[::max(1,len(ok)//6)][:6])+'\n')"

python $SKILL/scripts/run_eval.py --task $T --model $COPY --label copy --data $WORK/splits/practice.jsonl --ids-file $WORK/check_ids.txt --out $WORK/practice/copy.jsonl --max-tokens 16384 --jobs 2

python $SKILL/scripts/grade.py --task $T $G $WORK/practice/base.jsonl $WORK/practice/copy.jsonl

Das Tor ist nur bestanden, wenn alle drei gelten:

• repariert ≥ max(3, 20 % der geprüften Basisfehler),
• kaputt ≤ repariert ÷ 4,
• und, für Schleifenziele, der abgeschnittene Anteil um mindestens ein Viertel fällt.

Bestanden: gehe zu Schritt 10. Nicht bestanden: Schritt 9.

9. Eskaliere in dieser Reihenfolge; jede Sprosse ist eine weitere Übungsprüfung.

1. Der Nächstplatzierte Kandidat. Stelle die Kopie wieder her (copy_model.py --base $BASE --copy $COPY --restore), wende sie an und wiederhole die Schritte 7–8. Tue dies für höchstens zwei weitere Kandidaten.
2. Runde 2, wenn sich das Verhalten eher verschoben als verschwunden ist. Zum Beispiel schließt das Denken jetzt ab, aber die Schleife startet nach „ Antworte“ neu, oder ein neues unerwünschtes Muster taucht in den Antworten der Kopie auf. Behandle die bearbeitete Kopie als neue Basis:
   • erstelle COPY2 mit copy_model.py --base $COPY --copy $COPY2;
   • führe probe.py collect (oder collect-pairs) mit --model $COPY --runs $WORK/practice/copy.jsonl aus;
   • baue und überprüfe mit --model $COPY;
   • wende an mit --base $COPY --copy $COPY2;
   • überprüfe COPY2 wie in Schritt 8.
3. Stopp. Keine zuverlässige Verbesserung nach drei Prüfungen (oder nach dem vom Benutzer gesetzten Zeitbudget). Stelle die Kopie wieder her und melde das Ergebnis „Keine zuverlässige Verbesserung“ mit den Zahlen jedes Kandidaten. Für Qwen3.5-0.8B biete die veröffentlichte Mathematik-Bearbeitung als Vergleich an (sie senkte den abgeschnittenen Anteil von MMLU-Pro von 28,9 % auf 0,5 % in den Protokollen der Autoren; siehe Ende dieser Datei). Verwende sie nur, wenn der Benutzer zustimmt.

Verwende niemals zurückgehaltene Ergebnisse zur Auswahl; nur Übungsprüfungen entscheiden.

10. Zurückgehaltener Test von der Kopie (30–60 Min). Starte ihn, wenn der zurückgehaltene Basislauf seine längsten Antworten hinter sich hat:

python $SKILL/scripts/run_eval.py --task $T --model $COPY --label copy --data $WORK/splits/heldout.jsonl --ids-file $WORK/splits/test_ids.txt --out $WORK/test/copy.jsonl --jobs 2

python $SKILL/scripts/grade.py --task $T $G $WORK/test/base.jsonl $WORK/test/copy.jsonl --out $WORK/test/summary.json

Gib das Ergebnis aus dem gepaarten Resultat:

• „Klarer Gewinn“, wenn repariert > kaputt und Vorzeichentest p < 0,05.
• „Konsistent mit einem Gewinn, nicht bewiesen“, wenn repariert > kaputt, aber p ≥ 0,05; empfiehl einen größeren Test.
• „Kein Gewinn“, wenn repariert ≤ kaputt; empfiehl, die Kopie wiederherzustellen.

11. Bericht mit der Vorlage in references/evaluation.md:

• die zurückgehaltene Punktzahl vorher und nachher und die gepaarten repariert/kaputt-Zahlen;
• die Verhaltensraten (abgeschnitten, markiert, Denken abgeschlossen);
• jeder Kandidat mit seinen Überprüfungs- und Prüfzahlen und der Zufallskontrolle;
• die geänderten Gewichte;
• der Hinweis: Das Abschalten einer Gewohnheit ist keine neue Fähigkeit.

Fehler, die vorher Stunden gekostet haben (nicht wiederholen)

• Zu großer Batch oder zwei lange Jobs auf ihrem Höhepunkt. Ein Absturz durch Speichermangel tötet die laufenden Antworten, die die Schleifen sind. Verwende --batch auto --jobs 2 und starte niemals einen zweiten 32k-Job, während der erste auf seinen längsten Antworten ist. Der Supervisor startet abgestürzte Durchläufe mit der Hälfte des Batches neu.
• Auf ganze Durchläufe warten. Etwa 15 Schleifen reichen.
• Bearbeitungen im Speicher für die Auswertung. Nur probe.py screen wendet Bearbeitungen im Speicher an und nur für erzwungene Lesevorgänge.
• Der Überprüfung allein vertrauen. Ein Überprüfungsrückgang von −0,10 bei Schleifen hat nur 3 von 26 Schleifen in der Generierung kaputt gemacht, also führe immer das Tor aus.
• Einen Teildurchlauf bewerten oder Testfragen danach auswählen, welche zuerst fertig sind.
• Jobs mit pkill -f <Text> beenden, was auch Überwacher tötet, deren Befehlszeile diesen Text enthält.

Regeln (wie im Beitrag)

Behalte sie bei und sag im Bericht, dass du es getan hast.

• Kein Training. Keine Rückwärtsdurchläufe, Autograd, Optimierer oder iterative Anpassung von Gewichten an einen Verlust. Das Verändern von α oder Gewichten, bis eine Metrik sich verbessert, gilt als Anpassung. Die Auswahl aus der obigen festen Kandidatenliste nicht.
• Vorwärtsdurchläufe zur Messung sind erlaubt: Generierung, erzwungene Log-Wahrscheinlichkeiten, verborgene Zustände und MLP-Aktivierungen sowie Statistiken darüber oder über die Gewichte (Mittelwerte, Differenzen, SVD).
• Außerhalb des Gültigkeitsbereichs:
  • die Einbettungen, der (gebundene) Ausgabekopf und die letzte Norm (weights.py lehnt sie ab);
  • Multiplikation eines gesamten Tensors mit einer Konstanten;
  • globale Schärfung oder Abflachung;
  • Erzwingen des vorzeitigen Schließens des Denkens unabhängig vom Problem;
  • Entfernen von Sicherheitsverhalten: Ablehnungen, Schutzmaßnahmen, Erfüllung schädlicher Anfragen.
• Nur Gewichtswerte ändern sich. Behalte Namen, Formen, dtype, Konfiguration, Tokenisierer, Chat-Vorlage und Decodiereinstellungen bei.
• Aufteilungshygiene. Disjunkte Übungs- und Zurückhaltungssets, festgelegt vor jeder Bearbeitung. Sieh dir die zurückgehaltenen Ergebnisse einmal an, nachdem die Bearbeitung eingefroren ist.
• Offengelegte Auswahl. Der Bericht listet jeden versuchten Kandidaten und die Metrik auf, die den Gewinner ausgewählt hat.

Warum jeder Schritt so ist, wie er ist

• Kontrast: Die Richtung ist die mittlere Differenz, am Ausgang jeder Schicht, zwischen unerwünschtem und erwünschtem Text, der ansonsten abgeglichen ist.
  • Für Schleifen nimmt loops.py die 1.024 Tokens kurz vor dem Schleifenbeginn und 1.024 Tokens darin: gleiche Frage, gleiche Antwort, fast gleiche Position. Der Beginn ist der erste Punkt, an dem 90 % der nächsten 512 Tokens ein früheres 16-Gramm wiederholen.
  • Für andere Verhaltensweisen liefern die Paare den Abgleich.
• Schreiberspalten: score_j = (mittlere unerwünschte − mittlere erwünschte Aktivierung von Neuron j) × (u · W_down[:, j]); nimm die obersten k. Der statische Schreibzug u·W allein reicht nicht: Nur 21–22 der veröffentlichten 64 Spalten pro Schicht sind in seinen obersten 64.
• Die Bearbeitung: W'[:, S] = W[:, S] − α u (uᵀ W[:, S]), berechnet in float32 aus dem zu bearbeitenden Modell. α = 1 entfernt die Komponente, was für Schleifen nichts tat; α = 6 kehrt sie auf −5c um, sodass diese Neuronen gegen das Verhalten schreiben.
• Überprüfung: Die Änderung der mittleren Log-Wahrscheinlichkeit mit der angewendeten Bearbeitung. Unerwünschter Text sollte unwahrscheinlicher werden; erwünschter und sauberer Text sollten es bleiben. Eine normangepasste zufällige Richtung auf denselben Spalten ist die Kontrolle.
• Das Tor: Die Überprüfungszahlen sagen die Generierung nur lose voraus (siehe die Ergebnisse unten), also entscheidet eine kurze Generierungsprüfung an Übungsfragen vor dem zurückgehaltenen Test.
• Speichern: weights.py überschreibt nur die berührten safetensors-Shards aus den Rohdateien. Inferenz-Engines überschreiben oder verwerfen Tensoren beim Laden, also speichere niemals Gewichte von einer.
• Protokoll: Denken an, Temperatur 0,6, top_p 0,95, top_k 20, Anwesenheitsstrafe 1,5 nur auf generierten Tokens, 32.768 neue Tokens (--profile thinking). Alle Engines stimmen mit vLLMs Semantik überein.
• Paarung: Engines und Batch-Größen ändern die Zufallszahlen, also paare nach Frage innerhalb eines Vergleichs. Vergleiche niemals Punktzahlen, die auf unterschiedlichen Fragen oder mit unterschiedlichen Engines gemessen wurden.

R

… [für die Übersetzung gekürzt]