RTX 3090 vs RTX PRO 4000 (Blackwell): Inference, Training und Stromkosten
Ich wollte wissen, wie sich meine lokale RTX 3090 (gebraucht, ~700€) gegen eine oder mehrere RTX PRO 4000 Blackwell (145W, neu ~1400€) schlägt, einmal für LLM-Inference (Single User / Scripts / eigene Agents) und einmal fürs Fine-Tuning von Bildmodellen (AI-toolkit).
Mein Fazit vorweg: bei llama.cpp ist die 3090 oft schneller im Decoding, beim Training ist die RTX PRO 4000 bei mir leicht vorne, und bei den Stromkosten pro Token/Epoch ist die RTX PRO 4000 deutlich besser.
Wichtig: Die Zahlen unten sind Messwerte aus meinen Tests. Absolute Werte hängen stark von Modell, Quantisierung, Kontextlänge, Treibern/Build und Settings ab. Für die Stromkosten nutze ich bewusst die Max-Power als grobe Obergrenze (3090: 370W, RTX PRO 4000: 140W) und einen Strompreis von 0,30€/kWh.
Bei der RTX 5090 und der RTX PRO 6000 (Workstation) habe ich zusätzlich Messwerte mit Ø Power (gemessene Durchschnittsleistung), dort rechne ich dann auch mit Ø Power, weil es besser zur Realität passt.
LLM-Inference (llama.cpp)
Bei llama.cpp lohnt es sich, Prompt-Processing (pp) und Token-Generation (tg) getrennt zu betrachten:
- pp (Prompt Processing): Wie schnell der Prompt “durchgerechnet” wird.
- tg (Token Generation / Decoding): Wie schnell neue Output-Tokens erzeugt werden (gefühlt oft “die Geschwindigkeit”).
Ich habe zusätzlich llama-bench genutzt, weil das reproduzierbarer ist als eine Chat-Session mit wachsendem Kontext.
llama-bench (tg128 / pp512)
Qwen3-VL-32B (Q4), grob:
| GPU | pp512 (t/s) | tg128 (t/s) |
|---|---|---|
| RTX 3090 | ~1138 | ~36.24 |
| RTX PRO 4000 | ~1018 | ~27.11 |
| 4× RTX PRO 4000 | ~1136 | ~28.26 |
gpt-oss-20b (Q4), grob:
| GPU | pp512 (t/s) | tg128 (t/s) |
|---|---|---|
| RTX 3090 | ~4217 | ~216.12 |
| RTX PRO 4000 | ~5540 | ~184.66 |
Was ich daraus mitnehme:
- Die RTX 3090 ist in meinen Tests beim Decoding (tg) spürbar schneller, vor allem bei “größeren” Modellen wie Qwen3-VL-32B.
- Die RTX PRO 4000 ist beim pp teilweise vorne (z.B. gpt-oss-20b), aber das bedeutet nicht automatisch mehr tg.
- 4× RTX PRO 4000 skaliert für Single-Stream tg kaum, wenn das Modell sowieso bequem auf eine GPU passt. Multi-GPU hilft eher, um größere Modelle / mehr Kontext zu ermöglichen oder um Parallelität (mehrere gleichzeitige Runs) zu fahren.
120B-MoE: Warum CPU-MoE sinnvoll sein kann (und wann nicht)
Ein Grund, warum ich mir MoE-Modelle (Mixture of Experts) anschaue: damit kann man sehr große Modelle auch dann betreiben, wenn die GPU dafür eigentlich zu wenig VRAM hat. Praktisch läuft ein Teil der Experts dann auf der CPU (z.B. über --n-cpu-moe), während der “Rest” auf der GPU bleibt.
Das ist oft besser für die Performance, als einfach bei einem dichten Modell ein paar Layer per --n-gpu-layers (ngl) auf der CPU zu lassen. Denn CPU-Layer müssen bei jedem Token komplett durchlaufen werden. Bei MoE werden pro Token typischerweise nur wenige Experts aktiv, sodass CPU-Offload hier vergleichsweise “zielgerichtet” sein kann.
Der Nachteil: wenn zu viel auf der CPU landet oder die CPU (bzw. Speicherbandbreite) nicht mitkommt, wird --n-cpu-moe schnell zum Bottleneck und tg bricht ein. Als grobe Orientierung aus llama-bench auf 4× RTX PRO 4000:
| Setting | pp512 (t/s) | tg128 (t/s) |
|---|---|---|
n_cpu_moe=0 |
~2586 | ~134 |
n_cpu_moe=24 |
~542 | ~22 |
Zusätzlich habe ich gpt-oss-120b auch als “Single-GPU-Realtest” mit llama-cli laufen lassen (Q4_K_XL, --n-cpu-moe 24). Prompt-t/s schwankt dabei je nach Promptlänge/Session, die Generation ist stabiler:
| GPU | Prompt (t/s) | Generation (t/s) |
|---|---|---|
| RTX 3090 | ~65–301 | ~30.0–31.3 |
| RTX PRO 4000 | ~50.7–65.3 | ~11.9–12.9 |
Hinweis: Die gpt-oss-120b Chat-Session mit 1× RTX PRO 4000 lief auf einer anderen VastAI-Instanz als die oben gezeigten llama-bench Messungen (die ich auf 4× RTX PRO 4000 gemacht habe).
Fine-Tuning (Bildmodelle)
Hier war meine Erwartung: ohne exotische Offload-Setups sollte sich “GPU gegen GPU” fairer vergleichen lassen als bei Layer-Offloading (wo Host/PCIe/Timing schnell mit reinspielen).
“Qwen 2512” (Layer-Offloading)
In beiden Fine-Tuning-Tests gilt: 1 Epoch = 250 Steps.
Zeiten sind im Format mm:ss.
| GPU | Sampling (pro Bild) | Epoch |
|---|---|---|
| RTX PRO 4000 | 01:21 | 31:35 |
| RTX 3090 | 01:27 | 32:43 |
Z-image (Batch 1, ohne Layer-Offloading)
Dieser Test ist für mich aussagekräftiger.
Zeiten sind im Format mm:ss.
| GPU | VRAM | Preis (grob) | Sampling | Epoch | Power (Basis) |
|---|---|---|---|---|---|
| RTX 3090 | 24 GB | ~700€ | 00:11.45 | 13:21 | Max 370W |
| RTX PRO 4000 | 24 GB | ~1400€ | 00:10.80 | 12:03 | Max 140W |
| RTX 5090 | 32 GB | ~3000€ | 00:04.30 | 04:36 | Ø ~540W |
| RTX PRO 6000 Blackwell (Workstation) | 96 GB | ~8000€ | 00:03.00 | 03:24 | Ø ~590W |
Zwischen RTX 3090 und RTX PRO 4000 sind das bei mir grob ~5–10% Unterschied (je nach Metrik).
Kostenvergleich für ein Fine-Tuning über 10 Epochs (Z-image, Batch 1):
| GPU | Zeit (10 Epochs, hh:mm:ss) | Power-Basis | Stromkosten (10 Epochs) | VastAI Preis | VastAI Kosten (10 Epochs) |
|---|---|---|---|---|---|
| RTX 3090 | 2:13:30 | Max-Power (370W) | ~0,25€ | 0,19€/h | ~0,42€ |
| RTX PRO 4000 | 2:00:30 | Max-Power (140W) | ~0,08€ | 0,26€/h | ~0,52€ |
| RTX 5090 | 0:46:00 | Ø Power (~540W) | ~0,12€ | 0,39€/h | ~0,30€ |
| RTX PRO 6000 Blackwell (Workstation) | 0:34:00 | Ø Power (~590W) | ~0,10€ | 0,85€/h | ~0,48€ |
Stromkosten (lokal, nur GPU)
Ich rechne hier absichtlich nur den GPU-Strom grob gegen und ignoriere den Rest des Systems. Formel:
Kosten = (W / 1000) * (Zeit_in_Stunden) * 0,30€/kWh
Zeit_in_Stunden = Tokens / (t/s) / 3600
1.000.000 Output-Tokens
Auf Basis meiner llama-bench tg128 Werte (mit Max-Power als Obergrenze):
| Modell | GPU | tg128 (t/s) | Stromkosten pro 1M Output-Tokens |
|---|---|---|---|
| Qwen3-VL-32B (Q4) | RTX 3090 | ~36.24 | ~0,85€ |
| Qwen3-VL-32B (Q4) | RTX PRO 4000 | ~27.11 | ~0,43€ |
| gpt-oss-20b (Q4) | RTX 3090 | ~216.12 | ~0,14€ |
| gpt-oss-20b (Q4) | RTX PRO 4000 | ~184.66 | ~0,06€ |
Heißt: Die RTX PRO 4000 ist bei mir beim reinen “Strom pro Token” deutlich effizienter, obwohl sie beim tg-Decoding oft langsamer ist.
Fazit (für meinen Use Case)
Für Single User / Agents / Scripts ist die RTX 3090 in meinen llama.cpp-Tests meist schneller, aber die RTX PRO 4000 wirkt über die Laufzeit deutlich effizienter (Strom, Abwärme, ggf. Lautstärke) und ist beim Fine-Tuning in meinen Tests mindestens gleichauf bzw. leicht vorne.