diff --git a/ATHENA.md b/ATHENA.md index 98acb4e..4a95ed6 100644 --- a/ATHENA.md +++ b/ATHENA.md @@ -141,3 +141,5 @@ veröffentlicht werden. ## Verbindliche Benchmark-Referenz Bei neuen Modelltests die [gesicherte Qwen-Referenz vom 20.09.2026](benchmarks/athena-qwen38-reference-20260920/README.md) verwenden. **Qwen nicht automatisch erneut benchmarken.** Das Paket enthält sieben Pure-/MIX-Fälle, Originalantworten, feste Requests, Modell-SHA256 und Laufzeit-/GPU-Konfiguration. Neue Kandidaten separat messen; notwendige Abweichungen dokumentieren. Nur bei begründetem Rekalibrierungsbedarf eine neue Referenzversion anlegen, bestehende Ergebnisse unverändert erhalten. + +Abschluss des 20.09.: [Effizienz-/NVFP4-Prüfung](docs/ATHENA_EFFICIENCY_REVIEW_20260920.md). Pure/MIX bleiben produktiv; Medium startet nach abgefangenem GPU-Pufferfehler ohne Pipeline-Parallelisierung. Bei künftigem Tuning zuerst Speicherreserve und tatsächlichen Durchsatz prüfen. Native NVIDIA-NVFP4-Gewichte wurden nur auf Kapazität geprüft, nicht benchmarked. diff --git a/docs/ATHENA_EFFICIENCY_REVIEW_20260920.md b/docs/ATHENA_EFFICIENCY_REVIEW_20260920.md new file mode 100644 index 0000000..2364610 --- /dev/null +++ b/docs/ATHENA_EFFICIENCY_REVIEW_20260920.md @@ -0,0 +1,163 @@ +# Athena: abschließender Effizienz- und Quantisierungscheck + +20.09.2026. Ergebnis: **Die derzeitige Pure/MIX-Auswahl ist durch die vorhandenen +Messungen gut begründet. Ein nachgewiesener, einfacher schnellerer Ersatz fehlt. +Die Medium-Speicherkonfiguration bietet einen konkreten Ansatz für späteres +Tuning; ein absolutes Leistungsoptimum ist nicht nachgewiesen.** + +Heute zusätzlich ausgeführt: lesender Modellinventar-, Konfigurations-, +Hardware-, API-Health- und Speichercheck. Die Qwen-Referenz wurde wiederverwendet, +nicht erneut benchmarked. Keine neue Quantisierung geladen und kein Dienst +für diesen Abschlusscheck neu gestartet. Neue Belege stehen unter +`experiments/efficiency-review-20260920/`. + +## Welche beiden Modelle laufen tatsächlich? + +Es handelt sich um zwei Quantisierungen derselben Qwen3.8-27B-Familie: + +| Profil | Datei / Variante | Tatsächliche Tensorformate | Dateigröße | +|---|---|---|---:| +| Fast | Qwen3.8-27B-IQ4-MIX.gguf | IQ4_XS, IQ3_S, IQ2_S, Q4_K, Q5_K sowie F32-Hilfstensoren | 14,11 GB | +| Medium / Large / Ultra | qwen3.8-27b-IQ4_XS-pure.gguf | 506 IQ4_XS-Tensoren und 360 F32-Tensoren | 14,53 GB | + +Die GGUF-Header und Tensorbeschreibungen wurden direkt aus Athenas Dateien gelesen, +ohne Gewichtsdaten auf GPUs zu laden. **Keines der beiden ist natives NVFP4.** +„Pure“ heißt hier nicht unquantisiert/BF16. „MIX“ bedeutet gemischte +Quantisierungsformate, nicht ein zweites Modell oder eine NVIDIA-Laufzeit. +Die reine Anzahl der Tensoren ist kein Anteil der Parameter oder des Speichers. + +Die Anbieter dokumentieren [Pure](https://huggingface.co/jpetrina/Qwen3.8-27B-IQ4_XS-pure-GGUF) +und [MIX](https://huggingface.co/vmarcelo/Qwen3.8-27B-MIX_GGUF) getrennt. Entscheidend +für diesen Bericht sind jedoch die tatsächlich installierten Dateien samt +Prüfsummen in unserer eingefrorenen Referenz. + +Daneben existieren das separate Uncensored-Profil und die heute getesteten +ByteShape-/DFlash-Artefakte. Sie ersetzen keines der normalen Profile. + +## Die spezielle NVIDIA-Quantisierung + +Gemeint ist **NVFP4**. Der aktuelle offizielle +[NVIDIA-Checkpoint](https://huggingface.co/nvidia/Qwen3.8-27B-NVFP4) +mischt NVFP4 in MLP/LM-Head mit FP8 in Attention-Schichten. NVIDIA nennt +Blackwell sowie vLLM/SGLang als unterstützten Einsatzpfad; das Beispiel wurde +auf GB300 evaluiert. Die gemeldeten Qualitätswerte liegen nahe an BF16, zeigen +aber auch Rückgänge. Das ist keine Qualitäts- oder Geschwindigkeitsgarantie +für Athena. + +Die am 20.09. geprüfte Revision `482ca0f3832238542f8f5295dde86b5f22711d80` +enthält drei Safetensors-Dateien mit zusammen **21.921.697.280 Bytes = 20,42 GiB**. +Die 5080 bietet gemessen 15,92 GiB. Der vollständige gespeicherte Checkpoint ist +also bereits ohne KV-Cache und Arbeitsbereiche größer als deren Speicher. +Dateigröße ist nicht exakt Laufzeit-VRAM; selektives Laden oder Umwandlung wäre +ein eigener Kandidat und wurde hier nicht geprüft. Ein unveränderter, +vollständig GPU-residenter Einzelkarten-Test ist damit kein sinnvoller Schnelltest. +Quelle der Größen: [versionierte Dateiliste](https://huggingface.co/nvidia/Qwen3.8-27B-NVFP4/tree/482ca0f3832238542f8f5295dde86b5f22711d80). + +Die [5080 gehört zu Compute Capability 12.0](https://developer.nvidia.com/cuda/gpus). +Die 3060 ist keine Blackwell-Karte; beide VRAM-Mengen lassen sich nicht einfach +als ein gleichartiger nativer NVFP4-Beschleuniger behandeln. Das ist keine +Behauptung, dass jeder andere Ausführungspfad unmöglich ist: vLLM dokumentiert +auch einen W4A16/Marlin-Rückfall ohne native FP4-GEMM-Unterstützung, der bei +rechenintensiven Aufgaben langsamer sein kann. Ein gemischter Athena-Pfad müsste +separat integriert und gemessen werden. +[vLLM-ModelOpt-Dokumentation](https://docs.vllm.ai/en/latest/features/quantization/modelopt/). + +### Bereits vorhandener historischer NVIDIA-Versuch + +Das Register `docs/TESTED_MODELS.md` und die Originaldaten vom 22.08. enthalten +bereits eine **NVFP4-benannte Q4_K_M-GGUF-Datei**: +`Qwen3.8-27B-NVFP4-Q4_K_M-mtp.gguf`. Eingebettetes MTP lud nicht erfolgreich; +separates MTP lief bei 72K und erreichte damals 42,3 tok/s (MTP2) beziehungsweise +35,9 tok/s (MTP3). Sie wurde ohne ausreichenden Gesamtvorteil verworfen. + +Dieser historische GGUF-/llama.cpp-Versuch ist **kein Benchmark des aktuellen +nativen NVIDIA-Safetensors-Checkpoints**. Andere Laufzeit, Prompts und Sampling; +diese alten Zahlen nicht gegen heutige Messungen verrechnen. Der alte Versuch +wird nicht vergessen oder unnötig wiederholt. + +## Was schon sinnvoll konfiguriert ist + +- CUDA mit allen Modellschichten auf GPUs konfiguriert; Flash Attention aktiv. +- q 4_0-K/V reduziert den Speicherbedarf großer Kontexte. +- MTP ist eingerichtet; funktionierende Generation und Annahmestatistiken + sind in den Referenzen und jüngsten Produktionslogs belegt. +- Fast legt das Hauptmodell vollständig auf die 5080. Große Kontexte nutzen + die 3060 zusätzlich; Vision und TTS beanspruchen ebenfalls deren Speicher. +- Promptcache ist in Medium bereits eingeschaltet. Nicht als vermeintlich + neuen Geschwindigkeitsgewinn nochmals „aktivieren“. +- Gespeicherte Pure-Referenz: bei kurzen Eingaben etwa 85,8 tok/s Deutsch, + 122,1 tok/s Code und 2074,2 tok/s Prefill auf der 5080. Das sind spezifische + Messfälle, keine garantierten Werte für jede Medium-Anfrage. + +[ByteShape](QWEN38_BYTESHAPE_AB_20260920.md) spart Speicher und schafft mehr +Einzelkarten-Kontext, war im kontrollierten Kurzvergleich aber langsamer und +qualitativ nicht durchgehend gleichwertig. +[DFlash 2](DFLASH2_ONE_SLOT_20260920.md) funktioniert mit einem Slot und Draft auf +3060, zeigte aber keinen überzeugenden allgemeinen Vorteil. Beide Befunde +sprechen gegen einen ungeprüften Wechsel des Standards. + +## Konkrete offene Effizienzpunkte + +### 1. Medium startet ohne die zunächst versuchte Pipeline-Parallelisierung + +Im aktuellen Startprotokoll steht: + +``` +failed to allocate CUDA0 buffer of size 1437729280 +compute buffer allocation failed, retrying without pipeline parallelism +``` + +Danach lädt das Modell erfolgreich und wird gesund. Es ist ein abgefangener +GPU-Rechenpufferfehler, **kein Kernel-OOM oder Hostabsturz**. Das zusätzliche +Pufferbudget von etwa 1.338 GiB steht bei dieser Anordnung nicht zur Verfügung. + +Die aktuelle Medium-Anordnung belegt im Leerlauf 15.714/16.303 MiB auf der 5080 +und 10.920/12.288 MiB auf der 3060. Die 5080 ist somit bereits zu rund 96 % belegt. +Maximal gefüllter VRAM bedeutet nicht automatisch maximalen Durchsatz: fehlende +Arbeitsreserve kann einen effizienteren Ausführungspfad verhindern. + +**Sinnvollster späterer Vergleich:** dasselbe Pure/MTP-Modell mit etwas mehr +Reserve betreiben, etwa Microbatch 256 statt 512 und/oder leicht geändertem +Layer-Split. Dabei tatsächlich prüfen, ob der Pipeline-Rückfall entfällt und +ob Prefill, Einzelanfrage und zwei gleichzeitige Anfragen insgesamt profitieren. +Nicht blind die Microbatch verkleinern: auch das kann Prefill verlangsamen. +Eine Verbesserung ist hier noch nicht gemessen, deshalb heute keine Änderung. + +### 2. Temperatur und Kartenverbindung mitmessen + +Die gespeicherten Zwei-Sekunden-Samples der Pure/MIX-Referenz reichen bis +**81 °C auf der 5080 und 62 °C auf der 3060**. Der aktuelle Leerlauf ist kühler. +Thermisches Drosseln wurde nicht mit Taktraten/Throttle-Countern nachgewiesen; +die 81 °C sollten bei weiterem Tuning dennoch mit untersucht werden. Kein +Übertakten, keine Treiber-/BIOS-Änderungen aus diesem Audit. + +Die 3060 meldet eine aktuell ausgehandelte PCIe-Breite von x4, die 5080 x16. +Die gemeldeten maximalen Link-Generationen sind 3 beziehungsweise 4. Aktuelles +Gen 1 bei Leerlauf darf nicht als belegter dauerhafter Fehler interpretiert werden. +Die reale Transferbegrenzung unter Last wurde heute nicht separat gemessen; +die heterogene Verbindung bleibt ein Grund, die 5080 bevorzugt zu nutzen. + +### 3. Lange Eingaben und Cache-Nutzung + +Große Eingaben können die Wartezeit stärker bestimmen als Decode. Die gespeicherten +Langkontextmessungen zeigen den erheblichen Zeitbedarf. Für den Alltag lohnt die +Prüfung, ob Clients stabile gemeinsame Präfixe wiederverwenden und unnötig +wiederholten Kontext vermeiden. Cache ist eingeschaltet; eine schlechte Cache- +Trefferquote wurde hier nicht behauptet oder neu gemessen. Relevanten Kontext +oder notwendiges Reasoning nicht pauschal kürzen, um schönere Zahlen zu erzielen. + +## Abschlussprüfung und Entscheidung + +Alle geprüften Container gesund; Router health/readiness und Modell-health +bestanden. Keine erfassten Kernel-Panic-, Xid-, OOM-Kill- oder GPU-fallen-off- +Meldungen seit Tagesbeginn. Rund 43 GiB Host-RAM verfügbar; während der beiden +Ein-Sekunden-Intervalle von vmstat kein Swap-in/out. Belegter Swap-Inhalt allein +beweist kein aktuelles Pagingproblem. Das ist eine kurze Zustandsaufnahme, +keine Dauerlastgarantie. + +**Für heute bleibt Pure/MIX mit MTP produktiv.** NVFP4 ist grundsätzlich interessant, +aber das aktuelle offizielle Modell ist für die 16-GB-Einzelkarte zu groß und +für die gemischten GPUs kein einfacher Austausch. Priorität hat künftig ein +gezielter Medium-Speicher-/Pipeline-Test, nicht noch eine breite Modellrunde. +Alle bestehenden Messungen bleiben als Referenz erhalten. Kein neuer Benchmark, +Download oder Umbau ist für später automatisch eingeplant. diff --git a/docs/INFERENCE_OPTIMIZATION_TODO_20260920.md b/docs/INFERENCE_OPTIMIZATION_TODO_20260920.md index 56b51b4..70f5cc4 100644 --- a/docs/INFERENCE_OPTIMIZATION_TODO_20260920.md +++ b/docs/INFERENCE_OPTIMIZATION_TODO_20260920.md @@ -37,3 +37,7 @@ Stand: 20. September 2026. Modellfamilie bleibt Qwen3.8-27B. 20.09.2026: [Medium-Ladetest](DFLASH2_MEDIUM_QUICK_20260920.md) mit 160.000 Kontext/zwei Slots scheitert an zusätzlichem Draft-VRAM auf der 5080. Keine Durchsatz- oder Qualitätswerte. Bisheriges Medium wiederhergestellt; Punkt 3 bleibt offen und benötigt ein anderes Speicherlayout. Ein-Slot-Folgeversuche: [Bericht](DFLASH2_ONE_SLOT_20260920.md). Draft auf 5080 scheitert an Gerätezuordnung; Draft auf 3060 besteht kurze Texttests. Deutsch 37,8 tok/s, Code 75,5 tok/s: kein klarer Vorteil gegenüber gespeicherter MTP-Referenz. Dritter Rückfalltest nicht nötig. Vollständige Bewertung/Tuning in Punkt 3 bleibt offen. + +## Abschlussbewertung und nächste Priorität + +[Effizienzcheck](ATHENA_EFFICIENCY_REVIEW_20260920.md): Pure/MIX bleiben produktiv. Medium fällt beim Start wegen fehlender Rechenpuffer auf Betrieb ohne Pipeline-Parallelisierung zurück. Ein späterer Punkt-2-Test sollte gezielt Microbatch/Speicherreserve und tatsächlichen Durchsatz vergleichen. Native NVIDIA-NVFP4-Dateien umfassen 20,42 GiB; nur Kapazität geprüft, kein neuer Inferenzversuch. Keine weiteren Tests automatisch eingeplant. diff --git a/docs/TESTED_MODELS.md b/docs/TESTED_MODELS.md index 65e8cd0..767fef1 100644 --- a/docs/TESTED_MODELS.md +++ b/docs/TESTED_MODELS.md @@ -1,6 +1,6 @@ # Register getesteter Modelle -Stand: 19. September 2026 +Stand: 20. September 2026 Dieses Dokument ist die zentrale Sperrliste gegen doppelte Modelltests. Vor jedem Download müssen Repository, Dateiname, Basismodell, Fine-Tune und @@ -31,6 +31,13 @@ Statuswerte: | 08.09.2026 | `Tiel-Coder-35B-A3B-UD-IQ4_XS.gguf` | 160K vorgesehen | Testcontainer und Gewichte vorhanden gewesen, aber kein versionierter, belastbarer Abnahmebericht | **unvollständig**; nicht als getesteter Sieger behandeln | kein Ergebnisartefakt vorhanden | | 19.09.2026 | `ornith-ai/Ornith-1.5-35B-A3B-GGUF` / `Ornith-1.5-35B-Q4_K_M.gguf`, Revision `12393612fd4f730ff5aadc23e9b8f9648aa49ceb` | 76,8K–262K | 20–39 % kürzere Gesamtzeit und 39–77 % schnellerer Lang-Decode; Tool-Call, 48,6K-Recall und Vision korrekt. Die First-success-Async-Aufgabe war jedoch in allen drei Profilen und beiden Wiederholungen falsch | **verworfen als Produktionsersatz**; nur gestoppter Versuchskandidat | [Ornith A/B result](../experiments/ornith15-ab/results/RESULTS.md) | +## Ergänzungen vom 20.09.2026 + +- **Pure/MIX-Referenz eingefroren:** [sieben Messfälle](../benchmarks/athena-qwen38-reference-20260920/README.md). Für weitere Vergleiche wiederverwenden, nicht automatisch erneut benchmarken. +- **ByteShape GPU-5 / IQ4_XS 3.84bpw:** getestet; mehr Einzelkarten-Kontext, kein genereller Tempo-/Qualitätsvorteil. Kein Produktionsersatz. [Bericht](QWEN38_BYTESHAPE_AB_20260920.md). +- **DFlash2 Q4_K_M als Draft für Pure:** Ein-Slot-Kurztest mit Draft auf 3060 bestanden, kein klarer Geschwindigkeitsvorteil; breite Qualität/Langkontext offen. [Bericht](DFLASH2_ONE_SLOT_20260920.md). +- **nvidia/Qwen3.8-27B-NVFP4**, Revision `482ca0f3832238542f8f5295dde86b5f22711d80`: nur Metadaten-/Kapazitätsprüfung, **kein Inferenztest**. Vollständige Gewichtsdateien 20,42 GiB, kein direkter 16-GB-Einzelkarten-Kandidat. Nicht mit dem historischen NVFP4-benannten Q4_K_M-GGUF gleichsetzen. [Abschlussprüfung](ATHENA_EFFICIENCY_REVIEW_20260920.md). + ## Externe CPU-Helfermodelle Diese Versuche liefen nicht als Athena-Hauptprofil, sind aber relevant für diff --git a/experiments/efficiency-review-20260920/audit.py b/experiments/efficiency-review-20260920/audit.py new file mode 100644 index 0000000..25bc87e --- /dev/null +++ b/experiments/efficiency-review-20260920/audit.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +"""Read-only live checks; no inference request, container restart or system change.""" +import datetime,json,re,subprocess + +def run(*args):return subprocess.check_output(args,text=True,timeout=30).strip() +report={'checked_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'scope':'read-only state/health/capacity checks, existing benchmark reuse; no new throughput benchmark'} +names=['mike-ai-llama-medium','mike-ai-router','mike-ai-profile-controller','mike-ai-wireguard-gateway','mike-ai-qwen3-tts'] +report['containers']={} +for name in names: + d=json.loads(run('docker','inspect',name))[0] + report['containers'][name]={'running':d['State']['Running'],'health':d['State'].get('Health',{}).get('Status'),'started':d['State']['StartedAt'],'image':d['Image']} + if name==names[0]:report['medium_args']=d['Args'];start=d['State']['StartedAt'] +report['gpu']=run('nvidia-smi','--query-gpu=name,driver_version,memory.used,memory.total,utilization.gpu,temperature.gpu,power.draw,power.limit,pcie.link.gen.current,pcie.link.gen.max,pcie.link.width.current,pcie.link.width.max','--format=csv') +report['vmstat']=run('vmstat','1','3') +report['memory']=run('free','-m') +report['disk']=run('df','-h','/','/data') +report['uptime']=run('uptime') +probe='import urllib.request,json;print(json.dumps({p:json.load(urllib.request.urlopen("http://127.0.0.1:8081"+p,timeout=10)) for p in ["/health","/ready"]}))' +report['router']=json.loads(run('docker','exec','mike-ai-router','python','-c',probe)) +report['model_health']=json.loads(run('docker','exec','mike-ai-llama-medium','curl','-fsS','http://127.0.0.1:8080/health')) +props=json.loads(run('docker','exec','mike-ai-llama-medium','curl','-fsS','http://127.0.0.1:8080/props')) +report['model_properties']={k:props.get(k) for k in ['model_alias','model_ftype','model_path','total_slots','modalities','build_info']} +p=subprocess.run(['docker','logs','--since',start,names[0]],capture_output=True,text=True,timeout=30) +report['startup_findings']=[s for s in (p.stdout+p.stderr).splitlines() if re.search('failed to allocate|allocation failed|without pipeline|model loaded|initializing, n_slots',s)] +journal=run('journalctl','-k','--since','2026-09-20 00:00:00','--no-pager') +report['kernel_errors']=[s for s in journal.splitlines() if re.search('NVRM.*Xid|oom-kill|Out of memory: Killed process|Kernel panic|GPU has fallen off',s,re.I)] +report['tests']={'containers_healthy':all(x['running'] and x['health']=='healthy' for x in report['containers'].values()),'router_ready':report['router']['/ready'].get('upstream')=='ready','model_ready':report['model_health'].get('status')=='ok','no_recorded_kernel_faults':not report['kernel_errors']} +print(json.dumps(report,indent=2,ensure_ascii=False)) +assert all(report['tests'].values()),report['tests'] diff --git a/experiments/efficiency-review-20260920/gguf-inventory.json b/experiments/efficiency-review-20260920/gguf-inventory.json new file mode 100644 index 0000000..d31ed56 --- /dev/null +++ b/experiments/efficiency-review-20260920/gguf-inventory.json @@ -0,0 +1,38 @@ +[ + { + "path": "/data/models/qwen3.8-27b-iq4-xs-pure/qwen3.8-27b-IQ4_XS-pure.gguf", + "bytes": 14534384640, + "metadata": { + "general.architecture": "qwen35", + "general.name": "Qwen3.8-27B", + "general.quantization_version": 2, + "general.file_type": 30 + }, + "tensor_count": 866, + "tensor_types": { + "IQ4_XS": 506, + "F32": 360 + }, + "descriptor_end": 10996711 + }, + { + "path": "/data/models/qwen3.8-27b-iq4-mix/Qwen3.8-27B-IQ4-MIX.gguf", + "bytes": 14111614400, + "metadata": { + "general.architecture": "qwen35", + "general.name": "Hf_Symlink", + "general.quantization_version": 2, + "general.file_type": 30 + }, + "tensor_count": 866, + "tensor_types": { + "Q5_K": 1, + "F32": 360, + "IQ2_S": 1, + "IQ3_S": 96, + "IQ4_XS": 340, + "Q4_K": 68 + }, + "descriptor_end": 10995127 + } +] diff --git a/experiments/efficiency-review-20260920/historical-nvfp4-summary.json b/experiments/efficiency-review-20260920/historical-nvfp4-summary.json new file mode 100644 index 0000000..1088bc3 --- /dev/null +++ b/experiments/efficiency-review-20260920/historical-nvfp4-summary.json @@ -0,0 +1,71 @@ +[ + { + "source": "benchmarks/qwen38-final-pre-move-20260822/qwen38-final-acceptance-20260822/cases/08-latest-nvfp4-72k-embedded-mtp3-p010/result.json", + "case": { + "id": "08-latest-nvfp4-72k-embedded-mtp3-p010", + "model": "nvfp4-latest", + "context": 72000, + "split": [ + 72, + 28 + ], + "projector": "off", + "mtp": true, + "mtp_max": 3, + "quality": false, + "long_fill": 0.0, + "vision": false + }, + "model_path": "/models/qwen3.8-nvfp4-split/Qwen3.8-27B-NVFP4-Q4_K_M-mtp.gguf", + "status": "load_failed", + "loaded": false, + "mean_predicted_tps": null, + "warning": "Historical GGUF experiment, different runtime/prompts/settings. Not current native NVIDIA NVFP4 performance." + }, + { + "source": "benchmarks/qwen38-final-pre-move-20260822/qwen38-final-acceptance-20260822/cases/09-latest-nvfp4-72k-split-mtp2-p010/result.json", + "case": { + "id": "09-latest-nvfp4-72k-split-mtp2-p010", + "model": "nvfp4-latest", + "context": 72000, + "split": [ + 85, + 15 + ], + "projector": "off", + "mtp": true, + "mtp_max": 2, + "quality": false, + "long_fill": 0.0, + "vision": false + }, + "model_path": "/models/qwen3.8-nvfp4-split/Qwen3.8-27B-NVFP4-Q4_K_M-mtp.gguf", + "status": "complete", + "loaded": true, + "mean_predicted_tps": 42.27570687556832, + "warning": "Historical GGUF experiment, different runtime/prompts/settings. Not current native NVIDIA NVFP4 performance." + }, + { + "source": "benchmarks/qwen38-final-pre-move-20260822/qwen38-final-acceptance-20260822/cases/10-latest-nvfp4-72k-split-mtp3-p010/result.json", + "case": { + "id": "10-latest-nvfp4-72k-split-mtp3-p010", + "model": "nvfp4-latest", + "context": 72000, + "split": [ + 85, + 15 + ], + "projector": "off", + "mtp": true, + "mtp_max": 3, + "quality": true, + "long_fill": 0.0, + "vision": false + }, + "model_path": "/models/qwen3.8-nvfp4-split/Qwen3.8-27B-NVFP4-Q4_K_M-mtp.gguf", + "status": "complete", + "loaded": true, + "mean_predicted_tps": 35.94553417986984, + "warning": "Historical GGUF experiment, different runtime/prompts/settings. Not current native NVIDIA NVFP4 performance." + } +] diff --git a/experiments/efficiency-review-20260920/inspect_gguf.py b/experiments/efficiency-review-20260920/inspect_gguf.py new file mode 100644 index 0000000..e780632 --- /dev/null +++ b/experiments/efficiency-review-20260920/inspect_gguf.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python3 +"""Read GGUF metadata/tensor descriptors only; never loads weights or invokes GPUs.""" +import collections,json,pathlib,struct,sys +TYPES={0:'F32',1:'F16',2:'Q4_0',3:'Q4_1',6:'Q5_0',7:'Q5_1',8:'Q8_0',9:'Q8_1',10:'Q2_K',11:'Q3_K',12:'Q4_K',13:'Q5_K',14:'Q6_K',15:'Q8_K',16:'IQ2_XXS',17:'IQ2_XS',18:'IQ3_XXS',19:'IQ1_S',20:'IQ4_NL',21:'IQ3_S',22:'IQ2_S',23:'IQ4_XS',30:'BF16'} +def inspect(path): + with open(path,'rb') as f: + def read(fmt):return struct.unpack('<'+fmt,f.read(struct.calcsize('<'+fmt)))[0] + def string(keep=True): + n=read('Q') + if keep:return f.read(n).decode('utf-8') + f.seek(n,1) + def value(t,keep=False): + if t==8:return string(keep) + if t==9: + elem,n=read('I'),read('Q') + for _ in range(n):value(elem,False) + return None + fmt={0:'B',1:'b',2:'H',3:'h',4:'I',5:'i',6:'f',7:'?',10:'Q',11:'q',12:'d'}[t] + return read(fmt) + assert f.read(4)==b'GGUF' + version=read('I');assert version==3 + tensors,metas=read('Q'),read('Q');meta={} + for _ in range(metas): + key=string();t=read('I');keep=key in ['general.name','general.architecture','general.file_type','general.quantization_version'] + v=value(t,keep) + if keep:meta[key]=v + counts=collections.Counter() + for _ in range(tensors): + name=string();dims=read('I');shape=[read('Q') for _ in range(dims)];ty=read('I');offset=read('Q');counts[TYPES.get(ty,'type_'+str(ty))]+=1 + return {'path':str(path),'bytes':pathlib.Path(path).stat().st_size,'metadata':meta,'tensor_count':tensors,'tensor_types':dict(counts),'descriptor_end':f.tell()} +print(json.dumps([inspect(p) for p in sys.argv[1:]],indent=2)) diff --git a/experiments/efficiency-review-20260920/live-audit.json b/experiments/efficiency-review-20260920/live-audit.json new file mode 100644 index 0000000..5159f1f --- /dev/null +++ b/experiments/efficiency-review-20260920/live-audit.json @@ -0,0 +1,154 @@ +{ + "checked_at": "2026-09-20T19:15:15.116699+00:00", + "scope": "read-only state/health/capacity checks, existing benchmark reuse; no new throughput benchmark", + "containers": { + "mike-ai-llama-medium": { + "running": true, + "health": "healthy", + "started": "2026-09-20T19:07:06.261497776Z", + "image": "sha256:5e3c12c145b8045e5731b44b6b97033f24b327ae3d4a3fa85ecdd159cc844907" + }, + "mike-ai-router": { + "running": true, + "health": "healthy", + "started": "2026-09-20T19:07:16.676662725Z", + "image": "sha256:0448758bec6968b29263bcac0f8b4682c6d3029d626f7c12334698c11ef096bb" + }, + "mike-ai-profile-controller": { + "running": true, + "health": "healthy", + "started": "2026-09-20T19:07:16.548271903Z", + "image": "sha256:a5f156d94c4921e671fafa524cf9c0fe91e1cbec0113c1f19c136204d63f243f" + }, + "mike-ai-wireguard-gateway": { + "running": true, + "health": "healthy", + "started": "2026-09-17T09:05:07.164533904Z", + "image": "sha256:0d24e93c85a1c420b52b17666ede5fbd4672d92ab8dc28ea4ac5ba144ebc41d0" + }, + "mike-ai-qwen3-tts": { + "running": true, + "health": "healthy", + "started": "2026-09-19T13:47:00.227813668Z", + "image": "sha256:b363a01d08b1bbecbfc3ca6f585368fae2cfdc591f9ecca6643738369f9a9d98" + } + }, + "medium_args": [ + "--model", + "/models/qwen3.8-27b-iq4-xs-pure/qwen3.8-27b-IQ4_XS-pure.gguf", + "--mmproj", + "/models/qwen/mmproj-BF16.gguf", + "--mmproj-offload", + "--mmproj-device", + "CUDA1", + "--alias", + "qwen-medium", + "--ctx-size", + "160000", + "--flash-attn", + "on", + "--cache-type-k", + "q4_0", + "--cache-type-v", + "q4_0", + "--cache-prompt", + "--cache-ram", + "32768", + "--threads", + "6", + "--threads-batch", + "6", + "--batch-size", + "2048", + "--ubatch-size", + "512", + "--parallel", + "2", + "--kv-unified", + "--jinja", + "--reasoning", + "auto", + "--reasoning-preserve", + "--host", + "0.0.0.0", + "--port", + "8080", + "--metrics", + "--fit", + "off", + "--n-gpu-layers", + "all", + "--load-mode", + "none", + "--no-ui", + "--temperature", + "1.0", + "--top-p", + "0.95", + "--top-k", + "20", + "--device", + "CUDA0,CUDA1", + "--main-gpu", + "0", + "--split-mode", + "layer", + "--tensor-split", + "85,15", + "--spec-type", + "draft-mtp", + "--spec-draft-n-max", + "3", + "--spec-draft-type-k", + "f16", + "--spec-draft-type-v", + "f16", + "--spec-draft-p-min", + "0.05" + ], + "gpu": "name, driver_version, memory.used [MiB], memory.total [MiB], utilization.gpu [%], temperature.gpu, power.draw [W], power.limit [W], pcie.link.gen.current, pcie.link.gen.max, pcie.link.width.current, pcie.link.width.max\nNVIDIA GeForce RTX 3060, 615.71.09, 10920 MiB, 12288 MiB, 0 %, 45, 11.33 W, 170.00 W, 1, 3, 4, 16\nNVIDIA GeForce RTX 5080, 615.71.09, 15714 MiB, 16303 MiB, 0 %, 44, 14.16 W, 360.00 W, 1, 4, 16, 16", + "vmstat": "procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------\n r b swpd free buff cache si so bi bo in cs us sy id wa st gu\n 1 0 2780072 5840012 40828 41027564 222 585 7322 3314 9022 29 4 1 95 0 0 0\n 0 0 2780072 5835276 40828 41027564 0 0 0 24 1274 1982 1 0 98 0 0 0\n 0 0 2780072 5829488 40828 41027564 0 0 0 0 2129 4313 1 0 99 0 0 0", + "memory": "total used free shared buff/cache available\nMem: 48062 4423 5692 1579 40105 43638\nSwap: 49032 2714 46318", + "disk": "Filesystem Size Used Avail Use% Mounted on\n/dev/nvme0n1p2 868G 187G 637G 23% /\n/dev/nvme1n1p1 916G 821G 49G 95% /data", + "uptime": "21:15:17 up 3 days, 10:10, 1 user, load average: 0.12, 0.36, 0.57", + "router": { + "/health": { + "status": "ok", + "router": "alive" + }, + "/ready": { + "status": "ok", + "router": "alive", + "upstream": "ready" + } + }, + "model_health": { + "status": "ok" + }, + "model_properties": { + "model_alias": "qwen-medium", + "model_ftype": "IQ4_XS - 4.25 bpw", + "model_path": "/models/qwen3.8-27b-iq4-xs-pure/qwen3.8-27b-IQ4_XS-pure.gguf", + "total_slots": 2, + "modalities": { + "vision": true, + "video": true, + "audio": false + }, + "build_info": "b10964-b29c606e2" + }, + "startup_findings": [ + "0.02.693.409 E ggml_gallocr_reserve_n_impl: failed to allocate CUDA0 buffer of size 1437729280", + "0.02.693.409 E graph_reserve: failed to allocate compute buffers", + "0.02.693.412 W sched_reserve: compute buffer allocation failed, retrying without pipeline parallelism", + "0.05.408.988 I srv load_model: initializing, n_slots = 2, n_ctx_slot = 160000, kv_unified = 'true'", + "0.06.165.055 I srv llama_server: model loaded" + ], + "kernel_errors": [], + "tests": { + "containers_healthy": true, + "router_ready": true, + "model_ready": true, + "no_recorded_kernel_faults": true + } +} diff --git a/experiments/efficiency-review-20260920/nvidia-checkpoint-capacity.json b/experiments/efficiency-review-20260920/nvidia-checkpoint-capacity.json new file mode 100644 index 0000000..332705f --- /dev/null +++ b/experiments/efficiency-review-20260920/nvidia-checkpoint-capacity.json @@ -0,0 +1,25 @@ +{ + "repository": "nvidia/Qwen3.8-27B-NVFP4", + "revision": "482ca0f3832238542f8f5295dde86b5f22711d80", + "source": "https://huggingface.co/api/models/nvidia/Qwen3.8-27B-NVFP4?blobs=true", + "weight_files": [ + { + "name": "model-00001-of-00003.safetensors", + "bytes": 9965652544, + "sha256": "7d0fd155118901373eb0fd13ed3aae68f95be747bc205be72ebc41739c25ee80" + }, + { + "name": "model-00002-of-00003.safetensors", + "bytes": 9985757064, + "sha256": "98a7e9486baa860c792c9463a770cb9d017696bdd17606300a5b9334149f4c27" + }, + { + "name": "model-00003-of-00003.safetensors", + "bytes": 1970287672, + "sha256": "0506ad35dc21469708e7813bd76c592cef08bd0317b4a1fe899745ebe2435271" + } + ], + "total_weight_bytes": 21921697280, + "total_weight_gib": 20.416171550750732, + "status": "metadata/capacity review only; not downloaded or benchmarked" +} diff --git a/experiments/efficiency-review-20260920/reference-temperature-peaks.json b/experiments/efficiency-review-20260920/reference-temperature-peaks.json new file mode 100644 index 0000000..0363a60 --- /dev/null +++ b/experiments/efficiency-review-20260920/reference-temperature-peaks.json @@ -0,0 +1,7 @@ +{ + "scope": "2-second sampled peaks across saved Pure/MIX baseline cases; no clock/throttling proof", + "temperature_c": { + "NVIDIA GeForce RTX 3060": 62, + "NVIDIA GeForce RTX 5080": 81 + } +}