Hitonabi
469 lines
21 KiB
Bash
469 lines
21 KiB
Bash
#!/usr/bin/env bash
|
|
# Prüfstand-Runner (Täglich 02:00, ehemals Wöchentlich): Baut die Umgebung für den
|
|
# Harness (Modell-Sandkasten, GPU-RAM-Check) und zieht die Fäden.
|
|
# Läuft als Cron (Täglich 02:00, nach Radar/Checkout), nimmt Kandidaten aus der Queue
|
|
# und vergleicht sie gegen die BASELINE der Amtsinhaber.
|
|
#
|
|
# Modi:
|
|
# (ohne Argument) Cron-Modus: Baseline fehlt → Baseline messen; sonst ältesten
|
|
# Kandidaten aus der Queue prüfen; nichts zu tun → still.
|
|
# --baseline Amtsinhaber über llama-swap (:8080) neu vermessen.
|
|
# --kandidat <spec> einen Kandidaten-Spec (JSON) direkt prüfen.
|
|
#
|
|
# Leitplanken (User-Entscheid 17.07.): max 1 Kandidat je Lauf · Download-Deckel 35 GB
|
|
# (größere Kandidaten → Karte, Download erst nach Klick) · eigener Cache mit
|
|
# Auto-Aufräumen · Live-Betrieb bleibt unangetastet (eigener Server auf :5899) ·
|
|
# der Prüfstand EMPFIEHLT NUR — Rollen-Wechsel entscheidet der Commander per Karte.
|
|
# RAM-Wache vor dem Serverstart; Heredoc+Pipe-Falle vermieden (Temp-Dateien, Lehre 10.07.).
|
|
set -uo pipefail
|
|
|
|
MC="$HOME/mission-control-v2"
|
|
PSD="$MC/deploy/pruefstand"
|
|
VAULT="$HOME/wissens-vault"
|
|
STATE="$HOME/.hermes/state/pruefstand"
|
|
CACHE="/srv/models/pruefstand-cache"
|
|
HERMES="$HOME/.local/bin/hermes"
|
|
BENCH_BIN="${BENCH_BIN:-/opt/llamacpp-vulkan/llama-server}"
|
|
BENCH_PORT="${BENCH_PORT:-5899}"
|
|
LIVE="http://127.0.0.1:8080/v1"
|
|
JUDGE_MODEL="${PRUEFSTAND_JUDGE:-gpt-oss-120b}"
|
|
DECKEL_GB="${PRUEFSTAND_DECKEL_GB:-100}"
|
|
DEADLINE_MIN="${PRUEFSTAND_DEADLINE_MIN:-100}"
|
|
|
|
mkdir -p "$STATE/queue" "$STATE/done" "$STATE/ergebnisse"
|
|
|
|
# Suiten je Rolle (Amtsinhaber-Alias = Rollenname in llama-swap)
|
|
suiten_fuer() {
|
|
case "$1" in
|
|
hermes) echo "speed,agent,recherche,deutsch" ;;
|
|
coder) echo "speed,coding,agent" ;;
|
|
heavy) echo "speed,coding,recherche,deutsch" ;;
|
|
vision) echo "speed,vision" ;;
|
|
scout) echo "speed,agent,vision" ;;
|
|
*) echo "speed,recherche,deutsch" ;;
|
|
esac
|
|
}
|
|
|
|
briefkasten() { # $1=Betreff $2=Text (stiller Chronik-Spiegel, source=pruefstand)
|
|
curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \
|
|
-H 'Content-Type: application/json' \
|
|
--data "$(python3 - "$1" "$2" <<'PY'
|
|
import json, sys
|
|
print(json.dumps({"text": sys.argv[2], "subject": sys.argv[1],
|
|
"source": "pruefstand", "priority": "silent"}))
|
|
PY
|
|
)" >/dev/null 2>&1 || true
|
|
}
|
|
|
|
engine_build() { # installierte llama.cpp-Build-Nummer (leer, wenn nicht ermittelbar)
|
|
LD_LIBRARY_PATH="$(dirname "$BENCH_BIN")" "$BENCH_BIN" --version 2>&1 \
|
|
| grep -o 'version: [0-9]*' | grep -o '[0-9]*' || true
|
|
}
|
|
|
|
aggregiere_baseline() { # $1=Engine-Build — baut baseline.json aus den Rollen-Dateien
|
|
python3 - "$STATE" "${1:-}" <<'PY'
|
|
import glob, json, os, sys, time
|
|
state, build = sys.argv[1], sys.argv[2]
|
|
basis = {}
|
|
for f in glob.glob(os.path.join(state, "ergebnisse", "baseline-*.json")):
|
|
rolle = os.path.basename(f)[len("baseline-"):-len(".json")]
|
|
try:
|
|
basis[rolle] = json.load(open(f)).get("zusammenfassung", {})
|
|
except Exception:
|
|
pass
|
|
json.dump({"erhoben": time.strftime("%Y-%m-%d %H:%M"), "engine": build,
|
|
"rollen": basis},
|
|
open(os.path.join(state, "baseline.json"), "w"), ensure_ascii=False, indent=1)
|
|
print(f"\nBasislinie gespeichert ({len(basis)} Rollen, Engine b{build or '?'}).")
|
|
PY
|
|
}
|
|
|
|
# Tempo-Teil der Baseline neu messen (Lücke 2, 17.07.): Engine-Updates (So 04:30)
|
|
# verschieben das Tempo der Amtsinhaber — die Qualitäts-Zahlen bleiben gültig, aber
|
|
# Tempo-Vergleiche gegen eine alte Engine wären Geister-Zahlen.
|
|
speed_refresh() { # $1=neue Engine-Build-Nummer
|
|
local BUILD="$1"
|
|
echo "## PRÜFSTAND: Tempo-Baseline-Refresh (Engine jetzt b${BUILD}) am $(date '+%d.%m.%Y %H:%M')"
|
|
local rolle TMP
|
|
for rolle in hermes coder heavy vision scout; do
|
|
TMP="$STATE/ergebnisse/refresh-${rolle}.json"
|
|
echo "### $rolle"
|
|
python3 "$PSD/harness.py" --endpoint "$LIVE" --model "$rolle" --suites speed \
|
|
--out "$TMP" --judge-endpoint "$LIVE" --judge-model "$JUDGE_MODEL" \
|
|
--deadline-min 10 2>&1 | tail -2
|
|
python3 - "$STATE/ergebnisse/baseline-${rolle}.json" "$TMP" <<'PY'
|
|
import json, sys
|
|
try:
|
|
basis = json.load(open(sys.argv[1]))
|
|
neu = json.load(open(sys.argv[2]))
|
|
except Exception:
|
|
raise SystemExit
|
|
if "speed" in (neu.get("zusammenfassung") or {}):
|
|
basis.setdefault("zusammenfassung", {})["speed"] = neu["zusammenfassung"]["speed"]
|
|
basis["einzeln"] = ([e for e in basis.get("einzeln", []) if e.get("suite") != "speed"]
|
|
+ [e for e in neu.get("einzeln", []) if e.get("suite") == "speed"])
|
|
json.dump(basis, open(sys.argv[1], "w"), ensure_ascii=False, indent=1)
|
|
PY
|
|
rm -f "$TMP"
|
|
done
|
|
aggregiere_baseline "$BUILD"
|
|
briefkasten "Prüfstand" "Tempo-Baseline nach Engine-Wechsel neu gemessen (jetzt b${BUILD})."
|
|
}
|
|
|
|
zusammenfassung_lesen() { # $1=ergebnis.json → kompakte Zeilen "suite: x/y · Note · tg"
|
|
python3 - "$1" <<'PY'
|
|
import json, sys
|
|
try:
|
|
z = json.load(open(sys.argv[1])).get("zusammenfassung", {})
|
|
except Exception:
|
|
print("(Ergebnis nicht lesbar)"); raise SystemExit
|
|
for name, s in z.items():
|
|
teile = [f"{s['bestanden']}/{s['gesamt']}"]
|
|
if s.get("note_mittel"): teile.append(f"Note {s['note_mittel']}")
|
|
if s.get("tg_mittel"): teile.append(f"tg {s['tg_mittel']} t/s")
|
|
if s.get("pp_mittel"): teile.append(f"pp {s['pp_mittel']} t/s")
|
|
print(f" {name}: " + " · ".join(teile))
|
|
PY
|
|
}
|
|
|
|
# ---------------------------------------------------------------- Baseline
|
|
baseline_lauf() {
|
|
echo "## PRÜFSTAND: Basislinie der Amtsinhaber (erhoben am $(date '+%d.%m.%Y %H:%M'))"
|
|
echo "(Echte Prüfungen: Coding mit Unit-Tests, Agenten-Aufgaben, Recherche mit Zitat-Gate, Deutsch-Richter, Tempo.)"
|
|
local rollen="hermes coder heavy vision scout"
|
|
for rolle in $rollen; do
|
|
local out="$STATE/ergebnisse/baseline-${rolle}.json"
|
|
echo
|
|
echo "### Amtsinhaber \`$rolle\`"
|
|
python3 "$PSD/harness.py" --endpoint "$LIVE" --model "$rolle" \
|
|
--suites "$(suiten_fuer "$rolle")" --out "$out" \
|
|
--judge-endpoint "$LIVE" --judge-model "$JUDGE_MODEL" \
|
|
--deadline-min 30 2>&1 | tail -8
|
|
done
|
|
# embed: nur Funktions- und Latenz-Probe (Suiten ergeben hier keinen Sinn)
|
|
echo
|
|
echo "### Amtsinhaber \`embed\`"
|
|
python3 - "$LIVE" <<'PY'
|
|
import json, sys, time, urllib.request
|
|
t0 = time.time()
|
|
req = urllib.request.Request(sys.argv[1].rstrip("/") + "/embeddings",
|
|
data=json.dumps({"model": "embed", "input": "Prüfstand-Probe"}).encode(),
|
|
headers={"Content-Type": "application/json"})
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=60) as r:
|
|
d = json.load(r)
|
|
dim = len(d["data"][0]["embedding"])
|
|
print(f" ok · Dimension {dim} · {round((time.time()-t0)*1000)} ms")
|
|
except Exception as e:
|
|
print(f" FEHLER: {e}")
|
|
PY
|
|
# Sammel-Baseline schreiben (eine Datei, die Kandidaten-Läufe vergleichen)
|
|
aggregiere_baseline "$(engine_build)"
|
|
briefkasten "Prüfstand" "Basislinie der Amtsinhaber erhoben — künftige Kandidaten werden dagegen verglichen."
|
|
}
|
|
|
|
# ---------------------------------------------------------------- Kandidat
|
|
kandidat_lauf() { # $1=spec.json
|
|
local SPEC="$1"
|
|
local KEY ROLLE HF_ID WARUM
|
|
KEY="$(jq -r '.key' "$SPEC")"
|
|
ROLLE="$(jq -r '.rolle' "$SPEC")"
|
|
HF_ID="$(jq -r '.hf_id' "$SPEC")"
|
|
WARUM="$(jq -r '.warum // ""' "$SPEC")"
|
|
echo "## PRÜFSTAND: Kandidat \`$HF_ID\` für Rolle \`$ROLLE\` (am $(date '+%d.%m.%Y %H:%M'))"
|
|
[ -n "$WARUM" ] && echo "Anlass: $WARUM"
|
|
|
|
if [ -f "$STATE/done/${KEY}.json" ]; then
|
|
echo "Schon geprüft (State done/${KEY}) — nichts zu tun."
|
|
return 0
|
|
fi
|
|
|
|
# ---- GGUF im HF-Repo finden (bevorzugt ~Q4, ein Stück, Deckel prüfen)
|
|
local TREE_JSON="$STATE/tmp-tree-${KEY}.json"
|
|
curl -sf --max-time 60 \
|
|
"https://huggingface.co/api/models/${HF_ID}/tree/main?recursive=true" \
|
|
-o "$TREE_JSON" || { echo "HF-API nicht erreichbar — Abbruch, Spec bleibt in der Queue."; return 1; }
|
|
local AUSWAHL
|
|
AUSWAHL="$(python3 - "$TREE_JSON" "$DECKEL_GB" <<'PY'
|
|
import json, re, sys
|
|
baum = json.load(open(sys.argv[1]))
|
|
deckel = float(sys.argv[2]) * 2**30
|
|
dateien = [(e.get("path",""), (e.get("lfs") or {}).get("size") or e.get("size") or 0)
|
|
for e in baum if isinstance(e, dict)]
|
|
ggufs = [(p, g) for p, g in dateien if p.lower().endswith(".gguf")]
|
|
mmproj = next((p for p, g in ggufs if "mmproj" in p.lower()), "")
|
|
haupt = [(p, g) for p, g in ggufs if "mmproj" not in p.lower()]
|
|
# Split-GGUFs (…-00001-of-…) klammern wir in v1 aus — sauberer Einzeldatei-Download
|
|
haupt = [(p, g) for p, g in haupt if not re.search(r"-\d{5}-of-\d{5}", p)]
|
|
prio = ["q4_k_m", "ud-q4_k_m", "q4_k_s", "iq4", "q5_k_m", "q4", "q8_0"]
|
|
def rang(p):
|
|
pl = p.lower()
|
|
for i, q in enumerate(prio):
|
|
if q in pl:
|
|
return i
|
|
return len(prio)
|
|
haupt.sort(key=lambda t: (rang(t[0]), t[1]))
|
|
if not haupt:
|
|
print("KEINE"); raise SystemExit
|
|
pfad, groesse = haupt[0]
|
|
status = "OK" if groesse and groesse <= deckel else "ZU_GROSS"
|
|
print(status); print(pfad); print(groesse or 0); print(mmproj)
|
|
PY
|
|
)"
|
|
rm -f "$TREE_JSON"
|
|
local STATUS PFAD GROESSE MMPROJ
|
|
STATUS="$(printf '%s\n' "$AUSWAHL" | sed -n 1p)"
|
|
PFAD="$(printf '%s\n' "$AUSWAHL" | sed -n 2p)"
|
|
GROESSE="$(printf '%s\n' "$AUSWAHL" | sed -n 3p)"
|
|
MMPROJ="$(printf '%s\n' "$AUSWAHL" | sed -n 4p)"
|
|
local GB=$(( ${GROESSE:-0} / 1073741824 ))
|
|
|
|
if [ "$STATUS" = "KEINE" ]; then
|
|
echo "Kein brauchbares Einzel-GGUF im Repo (nur Splits oder gar keins) — Karte statt Download."
|
|
"$HERMES" kanban create "Prüfstand: ${HF_ID} braucht Handarbeit (kein Einzel-GGUF)" \
|
|
--body "Kandidat für Rolle ${ROLLE}. Im HF-Repo liegt kein Einzeldatei-GGUF ≤ ${DECKEL_GB} GB (vermutlich Split-Dateien). Bei Interesse manuell laden und 'bash ~/mission-control-v2/deploy/pruefstand/pruefstand.sh --kandidat <spec>' fahren. Anlass: ${WARUM}" \
|
|
--triage --created-by pruefstand --idempotency-key "pruefstand-${KEY}" >/dev/null 2>&1 || true
|
|
mv "$SPEC" "$STATE/done/${KEY}.spec.json"
|
|
echo "{\"status\":\"kein_gguf\"}" > "$STATE/done/${KEY}.json"
|
|
return 0
|
|
fi
|
|
if [ "$STATUS" = "ZU_GROSS" ]; then
|
|
echo "GGUF ${PFAD} ist ${GB} GB > Deckel ${DECKEL_GB} GB — Download wartet auf deinen Klick (Karte liegt bereit)."
|
|
"$HERMES" kanban create "Prüfstand: ${HF_ID} (${GB} GB) — Download freigeben?" \
|
|
--body "Kandidat für Rolle ${ROLLE}, Datei ${PFAD} (${GB} GB) liegt ÜBER dem Autonomie-Deckel von ${DECKEL_GB} GB (Entscheid 17.07.). Nach Freigabe: Spec wieder in ~/.hermes/state/pruefstand/queue/ legen und PRUEFSTAND_DECKEL_GB erhöhen oder manuell laden. Anlass: ${WARUM}" \
|
|
--triage --created-by pruefstand --idempotency-key "pruefstand-${KEY}" >/dev/null 2>&1 || true
|
|
mv "$SPEC" "$STATE/done/${KEY}.spec.json"
|
|
echo "{\"status\":\"zu_gross\",\"gb\":${GB}}" > "$STATE/done/${KEY}.json"
|
|
briefkasten "Prüfstand" "Kandidat ${HF_ID} (${GB} GB) wartet auf Download-Freigabe (Deckel ${DECKEL_GB} GB)."
|
|
return 0
|
|
fi
|
|
|
|
# ---- Platz- und RAM-Wache
|
|
local FREI_GB
|
|
FREI_GB="$(df --output=avail -BG /srv/models | tail -1 | tr -dc '0-9')"
|
|
if [ "${FREI_GB:-0}" -lt $(( GB + 20 )) ]; then
|
|
echo "Zu wenig Platz auf /srv/models (${FREI_GB} GB frei, gebraucht ~$((GB+20))) — Lauf verschoben, Spec bleibt in der Queue."
|
|
return 1
|
|
fi
|
|
|
|
# ---- Download in den Cache (mit Resume, Auto-Aufräumen am Ende)
|
|
mkdir -p "$CACHE/$KEY"
|
|
local ZIEL="$CACHE/$KEY/$(basename "$PFAD")"
|
|
echo "Lade ${PFAD} (${GB} GB) …"
|
|
curl -fL --retry 3 -C - --max-time 7200 -o "$ZIEL" \
|
|
"https://huggingface.co/${HF_ID}/resolve/main/${PFAD}" \
|
|
|| { echo "Download fehlgeschlagen — Spec bleibt in der Queue."; return 1; }
|
|
local MM_ZIEL=""
|
|
if [ -n "$MMPROJ" ] && { [ "$ROLLE" = "vision" ] || [ "$ROLLE" = "scout" ]; }; then
|
|
MM_ZIEL="$CACHE/$KEY/$(basename "$MMPROJ")"
|
|
curl -fL --retry 3 -C - --max-time 3600 -o "$MM_ZIEL" \
|
|
"https://huggingface.co/${HF_ID}/resolve/main/${MMPROJ}" || MM_ZIEL=""
|
|
fi
|
|
|
|
local MEM_FREI_GB
|
|
MEM_FREI_GB="$(awk '/MemAvailable/{printf "%d", $2/1048576}' /proc/meminfo)"
|
|
if [ "${MEM_FREI_GB:-0}" -lt $(( GB + 8 )) ]; then
|
|
echo "Zu wenig freier RAM (${MEM_FREI_GB} GB) für ein ${GB}-GB-Modell neben dem Warm-Set — Lauf verschoben."
|
|
return 1
|
|
fi
|
|
|
|
# ---- Kandidaten-Server auf dem Bench-Port (Live-Betrieb unangetastet)
|
|
echo "Starte Kandidaten-Server (:${BENCH_PORT}) …"
|
|
local MMFLAG=""
|
|
[ -n "$MM_ZIEL" ] && MMFLAG="--mmproj $MM_ZIEL"
|
|
$BENCH_BIN -m "$ZIEL" --host 127.0.0.1 --port "$BENCH_PORT" \
|
|
-c 32768 -ngl 999 -fa on --no-mmap --jinja $MMFLAG \
|
|
>/tmp/pruefstand-server.log 2>&1 &
|
|
local SPID=$!
|
|
trap 'kill $SPID 2>/dev/null; wait $SPID 2>/dev/null' RETURN
|
|
local BEREIT=0
|
|
for i in $(seq 1 240); do
|
|
curl -s --max-time 2 "http://127.0.0.1:$BENCH_PORT/health" | grep -q ok && { BEREIT=1; break; }
|
|
sleep 2
|
|
kill -0 $SPID 2>/dev/null || break
|
|
done
|
|
if [ "$BEREIT" != "1" ]; then
|
|
echo "LADE-CRASH — Kandidat startet nicht (Architektur zu neu für die Engine?):"
|
|
tail -3 /tmp/pruefstand-server.log
|
|
echo "{\"status\":\"lade_crash\"}" > "$STATE/done/${KEY}.json"
|
|
mv "$SPEC" "$STATE/done/${KEY}.spec.json"
|
|
rm -rf "${CACHE:?}/$KEY"
|
|
briefkasten "Prüfstand" "Kandidat ${HF_ID} startet auf unserer Engine nicht (Lade-Crash) — aussortiert."
|
|
return 0
|
|
fi
|
|
|
|
# ---- Das volle Programm
|
|
local OUT="$STATE/ergebnisse/kandidat-${KEY}.json"
|
|
echo "Fahre Suiten: $(suiten_fuer "$ROLLE") (Zeitbudget ${DEADLINE_MIN} min)"
|
|
python3 "$PSD/harness.py" --endpoint "http://127.0.0.1:$BENCH_PORT/v1" \
|
|
--model "kandidat" --suites "$(suiten_fuer "$ROLLE")" --out "$OUT" \
|
|
--judge-endpoint "$LIVE" --judge-model "$JUDGE_MODEL" \
|
|
--deadline-min "$DEADLINE_MIN" 2>&1 | tail -8
|
|
kill $SPID 2>/dev/null; wait $SPID 2>/dev/null; trap - RETURN
|
|
|
|
# ---- MTP-Fairness (Lücke 1, 17.07.): das Live-Hirn läuft MIT draft-mtp (+26 %) —
|
|
# ein Kandidat mit eingebautem MTP-Kopf würde ohne Zusatzmessung systematisch
|
|
# unterschätzt. Erkennung: Dateiname ODER nextn-Tensoren im GGUF-Kopf.
|
|
if printf '%s' "$PFAD" | grep -qi 'mtp' || head -c 8000000 "$ZIEL" 2>/dev/null | grep -aq 'nextn'; then
|
|
echo "MTP-Kopf erkannt — Zusatzmessung mit draft-mtp (Fairness gegen das Live-Hirn) …"
|
|
$BENCH_BIN -m "$ZIEL" --host 127.0.0.1 --port "$BENCH_PORT" \
|
|
-c 32768 -ngl 999 -fa on --no-mmap --jinja $MMFLAG \
|
|
--spec-type draft-mtp --spec-draft-n-max 3 \
|
|
>/tmp/pruefstand-server-mtp.log 2>&1 &
|
|
local MPID=$!
|
|
trap 'kill $MPID 2>/dev/null; wait $MPID 2>/dev/null' RETURN
|
|
local MBEREIT=0
|
|
for i in $(seq 1 120); do
|
|
curl -s --max-time 2 "http://127.0.0.1:$BENCH_PORT/health" | grep -q ok && { MBEREIT=1; break; }
|
|
sleep 2
|
|
kill -0 $MPID 2>/dev/null || break
|
|
done
|
|
if [ "$MBEREIT" = "1" ]; then
|
|
local MOUT="$STATE/ergebnisse/kandidat-${KEY}-mtp.json"
|
|
python3 "$PSD/harness.py" --endpoint "http://127.0.0.1:$BENCH_PORT/v1" \
|
|
--model "kandidat" --suites speed --out "$MOUT" \
|
|
--judge-endpoint "$LIVE" --judge-model "$JUDGE_MODEL" --deadline-min 10 2>&1 | tail -2
|
|
python3 - "$OUT" "$MOUT" <<'PY'
|
|
import json, sys
|
|
haupt = json.load(open(sys.argv[1]))
|
|
try:
|
|
s = (json.load(open(sys.argv[2])).get("zusammenfassung") or {}).get("speed")
|
|
except Exception:
|
|
s = None
|
|
if s:
|
|
haupt.setdefault("zusammenfassung", {})["speed_mtp"] = s
|
|
json.dump(haupt, open(sys.argv[1], "w"), ensure_ascii=False, indent=1)
|
|
PY
|
|
else
|
|
echo "Kandidat startet mit draft-mtp NICHT — Zusatzmessung entfällt (im Steckbrief zählt der Basis-Wert)."
|
|
fi
|
|
kill $MPID 2>/dev/null; wait $MPID 2>/dev/null; trap - RETURN
|
|
fi
|
|
|
|
# ---- Steckbrief: Kandidat vs. Amtsinhaber
|
|
local BERICHT="$STATE/ergebnisse/kandidat-${KEY}.md"
|
|
local SIEGER_FLAG="$STATE/tmp-sieger-${KEY}"
|
|
rm -f "$SIEGER_FLAG"
|
|
python3 - "$OUT" "$STATE/baseline.json" "$ROLLE" "$HF_ID" "$WARUM" "$BERICHT" "$SIEGER_FLAG" <<'PY'
|
|
import json, sys, time
|
|
kand = json.load(open(sys.argv[1]))
|
|
try:
|
|
basis = json.load(open(sys.argv[2]))["rollen"].get(sys.argv[3], {})
|
|
except Exception:
|
|
basis = {}
|
|
rolle, hf_id, warum, ziel = sys.argv[3], sys.argv[4], sys.argv[5], sys.argv[6]
|
|
kz = kand.get("zusammenfassung", {})
|
|
zeilen = [f"# Prüfstand-Steckbrief: {hf_id}",
|
|
f"Rolle: **{rolle}** · erhoben {time.strftime('%d.%m.%Y %H:%M')}",
|
|
f"Anlass: {warum}" if warum else "", "",
|
|
"| Suite | Kandidat | Amtsinhaber |", "|---|---|---|"]
|
|
punkte_k = punkte_b = faelle = 0
|
|
for name in sorted(set(kz) | set(basis)):
|
|
def fmt(s):
|
|
if not s: return "—"
|
|
t = f"{s['bestanden']}/{s['gesamt']}"
|
|
if s.get("note_mittel"): t += f" · Note {s['note_mittel']}"
|
|
if s.get("tg_mittel"): t += f" · tg {s['tg_mittel']}"
|
|
if s.get("pp_mittel"): t += f" · pp {s['pp_mittel']}"
|
|
return t
|
|
zeilen.append(f"| {name} | {fmt(kz.get(name))} | {fmt(basis.get(name))} |")
|
|
if name in kz and name in basis and not name.startswith("speed"):
|
|
faelle += 1
|
|
punkte_k += kz[name]["bestanden"] / max(1, kz[name]["gesamt"])
|
|
punkte_b += basis[name]["bestanden"] / max(1, basis[name]["gesamt"])
|
|
# Tempo: best-of speed/speed_mtp — die Baseline ist live MIT MTP gemessen (Fairness)
|
|
tg_k = max(((kz.get(s) or {}).get("tg_mittel") or 0) for s in ("speed", "speed_mtp"))
|
|
tg_b = (basis.get("speed") or {}).get("tg_mittel") or 0
|
|
zeilen.append("")
|
|
if faelle:
|
|
qk, qb = punkte_k / faelle, punkte_b / faelle
|
|
tempo = (f"Tempo {round(100*tg_k/tg_b-100):+d} % vs. Amtsinhaber" if tg_k and tg_b
|
|
else "Tempo-Vergleich unvollständig")
|
|
if qk >= qb and tg_k >= 0.8 * (tg_b or tg_k):
|
|
urteil = "KANDIDAT SIEHT STARK AUS — Auto-Adoption greift (Etappe E5)."
|
|
open(sys.argv[7], "w").write("1")
|
|
elif qk >= qb:
|
|
urteil = "Qualität hält mit, aber deutlich langsamer — vermutlich kein Aufsteiger."
|
|
else:
|
|
urteil = "Qualität unter Amtsinhaber — kein Aufsteiger."
|
|
zeilen.append(f"**Einordnung:** Bestehensquote {qk:.0%} vs. {qb:.0%} · {tempo}. {urteil}")
|
|
zeilen.append("")
|
|
zeilen.append("_Auto-Adoption (Etappe E5): Der Prüfstand tauscht Sieger-Modelle nun selbstständig aus._")
|
|
text = "\n".join(z for z in zeilen if z is not None)
|
|
open(ziel, "w", encoding="utf-8").write(text + "\n")
|
|
print(text)
|
|
PY
|
|
|
|
# ---- Vault-Bericht + Karte + stille Chronik, dann Cache aufräumen
|
|
mkdir -p "$VAULT/pruefstand"
|
|
cp "$BERICHT" "$VAULT/pruefstand/${KEY}.md" 2>/dev/null || true
|
|
( cd "$VAULT" 2>/dev/null && git add "pruefstand/${KEY}.md" >/dev/null 2>&1 \
|
|
&& git commit -q -m "pruefstand: Steckbrief ${KEY}" >/dev/null 2>&1 ) || true
|
|
"$HERMES" kanban create "Prüfstand-Ergebnis: ${HF_ID} für Rolle ${ROLLE}" \
|
|
--body "$(cat "$BERICHT")" \
|
|
--triage --created-by pruefstand --idempotency-key "pruefstand-${KEY}" >/dev/null 2>&1 || true
|
|
briefkasten "Prüfstand" "Kandidat ${HF_ID} (Rolle ${ROLLE}) geprüft — Steckbrief im Auftrags-Kanban und Vault (pruefstand/${KEY}.md)."
|
|
mv "$SPEC" "$STATE/done/${KEY}.spec.json" 2>/dev/null || true
|
|
cp "$OUT" "$STATE/done/${KEY}.json" 2>/dev/null || echo "{\"status\":\"geprueft\"}" > "$STATE/done/${KEY}.json"
|
|
|
|
# ---- Auto-Adoption (Etappe E5)
|
|
if [ -f "$SIEGER_FLAG" ]; then
|
|
echo "Kandidat hat gewonnen — starte Auto-Adoption für Rolle $ROLLE..."
|
|
local FINAL_DIR="/srv/models/${HF_ID//\//-}-GGUF"
|
|
sudo -n mkdir -p "$FINAL_DIR"
|
|
sudo -n mv "$ZIEL" "$FINAL_DIR/"
|
|
local FINAL_GGUF="$FINAL_DIR/$(basename "$PFAD")"
|
|
local FINAL_MMPROJ=""
|
|
if [ -n "$MM_ZIEL" ]; then
|
|
sudo -n mv "$MM_ZIEL" "$FINAL_DIR/"
|
|
FINAL_MMPROJ="$FINAL_DIR/$(basename "$MMPROJ")"
|
|
fi
|
|
sudo -n chown -R hitonabi:hitonabi "$FINAL_DIR" 2>/dev/null || true
|
|
|
|
# Config updaten
|
|
local CONFIG="$MC/deploy/llama-swap.config.yaml"
|
|
python3 "$PSD/auto_adopt.py" "$CONFIG" "$ROLLE" "$HF_ID" "$FINAL_GGUF" "$FINAL_MMPROJ"
|
|
|
|
# Reload llama-swap (via worker oder systemctl)
|
|
if systemctl --user is-active --quiet llama-swap; then
|
|
systemctl --user restart llama-swap
|
|
briefkasten "Prüfstand Auto-Adoption" "Rolle '$ROLLE' wurde erfolgreich durch '$HF_ID' ersetzt (Neustart erledigt)."
|
|
else
|
|
briefkasten "Prüfstand Auto-Adoption" "Rolle '$ROLLE' wurde durch '$HF_ID' ersetzt (llama-swap war inaktiv)."
|
|
fi
|
|
rm -f "$SIEGER_FLAG"
|
|
fi
|
|
|
|
rm -rf "${CACHE:?}/$KEY"
|
|
echo
|
|
echo "(Cache aufgeräumt; Roh-Ergebnisse: $STATE/ergebnisse/kandidat-${KEY}.*)"
|
|
}
|
|
|
|
# ---------------------------------------------------------------- Einstieg
|
|
case "${1:-}" in
|
|
--baseline)
|
|
baseline_lauf
|
|
;;
|
|
--kandidat)
|
|
[ -n "${2:-}" ] || { echo "Nutzung: pruefstand.sh --kandidat <spec.json>"; exit 1; }
|
|
kandidat_lauf "$2"
|
|
;;
|
|
*)
|
|
if [ ! -f "$STATE/baseline.json" ]; then
|
|
baseline_lauf
|
|
exit 0
|
|
fi
|
|
# Engine gewechselt seit der Baseline? → Tempo-Teil neu messen (Geister-Zahlen-Schutz)
|
|
BUILD="$(engine_build)"
|
|
BASE_BUILD="$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1])).get("engine") or "")' "$STATE/baseline.json" 2>/dev/null || true)"
|
|
if [ -n "$BUILD" ] && [ "$BUILD" != "$BASE_BUILD" ]; then
|
|
speed_refresh "$BUILD"
|
|
fi
|
|
NAECHSTER="$(ls -1tr "$STATE/queue/"*.json 2>/dev/null | head -1 || true)"
|
|
if [ -n "$NAECHSTER" ]; then
|
|
kandidat_lauf "$NAECHSTER"
|
|
fi
|
|
# keine Queue + keine Engine-Drift → LEERER stdout → --no-agent-Cron bleibt still
|
|
;;
|
|
esac
|