es ist additionally grundsätzlich kostenlos.“ Ich habe das gesagt, Sie haben das wahrscheinlich gesagt, und es ist die Artwork von Behauptung, die wahr klingt, bis jemand sie misst. Additionally habe ich es gemessen.
Die Field ist „ardi“ – eine openSUSE-Maschine mit einer einzelnen RTX 3090 (24 GB). Darauf habe ich einen kontrollierten Benchmark durchgeführt: drei lokale Modelle, die von Ollama bedient wurden und jeweils unter einer identischen festen Arbeitslast betrieben wurden, während ein Dashboard jeden Lauf durch das bewertete echte GPU-Energie, die es verbrannt hat. Keine Schätzung der Thermal-Design-Leistung, keine Schätzung auf der Rückseite des Umschlags – die Leistung wird alle 10 Sekunden von nvidia-smi abgetastet und über das genaue Begin-Finish-Fenster jedes Laufs integriert, zu meinem tatsächlichen Tag-/Nacht-Stromtarif: 0,30 BGN am Tag / 0,18 BGN in der Nacht (Bulgarischer Lew – mein tatsächlicher Versorgungssatz; in diesem Artikel in EUR umgerechnet unter der festen EZB-Kopplung, 1 BGN ≈ 0,5113 €).
Das Ergebnis ist eine Zahl professional Modell: Euro professional Million ausgegebener Token. Fünf der acht von mir gemessenen Modelle waren günstiger als eine gehostete Cloud-API. Bei drei struggle das nicht der Fall – und es sind nicht die drei, die man aufgrund der Parameteranzahl allein erraten würde.
Die Behauptung, die ich testen wollte
Die Volksweisheit besagt, dass lokale Inferenz die kostengünstige Choice ist – Sie haben die GPU gekauft, der marginale Token ist kostenlos, die Cloud ist das Ding, bei dem der Zähler läuft. Jeder Teil davon verdient eine Nummer, additionally hier ist die, nach der ich gesucht habe: die Grenzenergiekosten für die lokale Generierung eines TokensModell für Modell, und wie es im Vergleich zu den Gebühren einer gehosteten „Flash“-Klasse-API für denselben Token abschneidet.
Um das zu einer Messung und nicht zu einem Argument zu machen, brauchte ich drei Dinge, die konstant gehalten wurden: die gleiche Arbeitslast für jedes Modell, die gleiche {Hardware} und ein Messgerät, dem ich vertraute, um die GPU bei jedem Lauf abzulesen. Der dritte Punkt ist der schwierige Teil zu Hause – da kommt das Instrument ins Spiel.
Die Methode
Drei Modelle, ausgewählt, um den Größenbereich abzudecken, den ich tatsächlich auf der Field habe: gemma3:1b (winzig), gemma4:26b (Googles Gemma 4–25,8B Parameter unter der Haube; ollama rundet es im Tag einfach auf „26b“) und gemma3:27b (das ältere große). Alle drei sind Q4_K_M-quantisierte GGUF-Gewichte, die durch Ollama gezogen werden, sodass der Vergleich hinsichtlich der Quantisierung gleichwertig ist. Jeder bekam das gleiche feste Arbeitsbelastung – eine Schleife von 256-Token-Generationen, die fünf feste Eingabeaufforderungen durchläuft – aufrechterhalten für ~4 Minuten (240 s)So erreichte die GPU einen stabilen Zustand und wurde nicht nach einem kalten ersten Anruf beurteilt.
Während jedes Modell lief, habe ich es als verfolgt Preisliches Experiment in HomeLab Monitor – mein eigenes Dashboard, Open Supply, MIT, ein Container. Es erfasst alle 10 s die GPU-Leistung von nvidia-smi und integriert bei einem verfolgten Lauf die Leistung über das Begin-Finish-Fenster des Laufs in kWh und multipliziert sie dann mit dem jeweils geltenden Tarif (Tag vs. Nacht) – in der Währung, mit der ich es konfiguriert habe, BGN . Das umrechnet: „Was hat dieses Modell gekostet?“ von einer Vermutung zu einer gemessenen Zahl; Zur besseren Lesbarkeit rechne ich dann in EUR um.
Dann die Arithmetik, die einen 4-Minuten-Lauf in eine vergleichbare Geschwindigkeit umwandelt:
€ per 1M output tokens = (run_cost_BGN × 0.5113) ÷ (output_tokens / 1,000,000)
Der untenstehende Benchmark der drei Modellgenerationen ist durchgängig reproduzierbar. Hier erfahren Sie, wie Sie es auf Ihrer eigenen Field aufstellen.
Schritt 1 – Monitor aufrufen (ein Container)
Auf der Maschine mit der GPU:
COMPOSE_URL=https://uncooked.githubusercontent.com/SikamikanikoBG/homelab-monitor/predominant/docker-compose.yml
curl -fsSLO "$COMPOSE_URL"
docker compose up -dÖffnen Sie http://
Schritt 2 – Prägen Sie einen Ingest-Schlüssel
Das Benchmark-Skript muss Läufe in den Hub pushen und benötigt daher einen Schlüssel. Einstellungen → Integrationen → Schlüssel erstellen. Der Schlüssel (ein hlm_…-String) wird einmal angezeigt – kopieren Sie ihn dann, er wird nicht mehr angezeigt. Bewahren Sie es in einer Umgebungsvariable auf; Fügen Sie es nicht in das Skript ein.
export HOMELAB_KEY="hlm_xxxxxxxxxxxxxxxxxxxx"
Das gleiche Panel hat eine Shopper herunterladen Hyperlink für die Python-Datei, die Sie in Schritt 3 verwenden, und eine Schnellstartanleitung zum Kopieren und Einfügen – dieser eine Bildschirm deckt additionally die nächsten beiden Schritte ab.
Schritt 3 – Schnappen Sie sich den Tiny Shopper
Der Hub bedient seinen eigenen Python-Shopper. Es ist nur stdlib – nichts, was per Pip installiert werden muss:
CLIENT_URL=http://<hub>:9800/static/homelab_run.py
curl -O "$CLIENT_URL"Diese eine Datei ist die gesamte Monitoring-API. Das Muster ist bewusst klein gehalten: Einmal konfigurieren, dann jeden Arbeitsblock in einen Ausführungskontextmanager einschließen und darin Metriken protokollieren.
import homelab_run as homelab
homelab.configure(url="http://<hub>:9800", key="hlm_...")
with homelab.run("llm-cost-gemma3-1b",
params={"mannequin": "gemma3:1b", "engine": "ollama",
"gpu": "RTX 3090 24GB", "num_predict": 256}) as r:
# ... do the work ...
r.log_metric("tokens_per_sec", tps, step=i)Wenn der With-Block geöffnet wird, markiert der Hub einen Laufstart; Wenn es geschlossen wird, markiert es das Ende und bewertet die zwischenzeitlich verbrannte GPU-Energie. Das Fenster ist das Maß.
Schritt 4 – Benchmark schreiben
Der Arbeitsaufwand besteht nur darin, dass Ollama /api/generate in einer Schleife arbeitet und die Felder ausliest, die Ollama zurückgibt, damit wir sie erhalten actual Tokens professional Sekunde statt einer Wanduhr-Näherung. Die beiden Bereiche, auf die es ankommt, sind eval_count (generierte Token) und eval_duration (Nanosekunden, die für deren Generierung aufgewendet wurden):
import json, time, urllib.request
OLLAMA = "http://localhost:11434"
def ollama_generate(mannequin, immediate):
physique = json.dumps({
"mannequin": mannequin, "immediate": immediate, "stream": False,
"choices": {"num_predict": 256, "temperature": 0.7},
}).encode()
req = urllib.request.Request(OLLAMA + "/api/generate", information=physique,
headers={"Content material-Kind": "software/json"})
with urllib.request.urlopen(req, timeout=600) as resp:
return json.hundreds(resp.learn())Fahren Sie dann jedes Modell für eine festgelegte Dauer unter Final, gefolgt von einem verfolgten Lauf:
def bench(mannequin, duration_s=240):
ollama_generate(mannequin, "Say whats up.") # heat up - exclude the chilly begin
run = homelab.run(f"llm-cost-{mannequin.substitute(':', '-')}",
params={"mannequin": mannequin, "engine": "ollama",
"gpu": "RTX 3090 24GB", "num_predict": 256,
"workload": "fixed-prompt-loop"},
tags=("llm-cost", "benchmark"))
tot_out = 0
t0 = time.time(); step = 0
with run as r:
whereas time.time() - t0 < duration_s:
res = ollama_generate(mannequin, PROMPTS(step % len(PROMPTS)))
ec, ed = res.get("eval_count", 0), res.get("eval_duration", 1) # ed in ns
tps = ec / (ed / 1e9) if ed else 0.0
tot_out += ec
r.log_metric("tokens_per_sec", spherical(tps, 2), step=step)
step += 1
r.log_params({"total_output_tokens": tot_out})
return run.id, tot_outDurch einen Aufwärmaufruf vor dem Zeitfenster wird die Kaltstartlatenz aus der Messung ausgeschlossen. Der time.sleep(15), den ich zwischen den Modellen eingefügt habe (nicht gezeigt), hält jedes Preisfenster sauber getrennt, sodass der Schwanz eines Modells nicht in die Rechnung des nächsten Modells gelangt.
Schritt 5 – Lesen Sie den Runback und die Preise
Führen Sie das Skript für alle drei Modelle aus und öffnen Sie das ExperimenteTab. Jeder Lauf ist nun eine Reihe, die ihre wahre Energie und Kosten trägt:
Klicken Sie in einen Lauf und Sie erhalten die GPU-Leistungskurve für genau dieses Fenstermit der Preisunterschrift darunter – der Rohstoff, aus dem die Euro-Zahl berechnet wird:
Der Hub legt die Kosten jedes Laufs auch programmgesteuert offen, sodass die endgültige Aufteilung im Skript erfolgen kann:
pulled = homelab.pull(run_id) # price, energy_kwh, avg_w, energy curve - price is in BGN
eur_per_mtok = spherical((pulled("price") * 0.5113) / (tot_out / 1e6), 4)Die Zahlen
Später ging ich zurück und fügte fünf weitere Modelle hinzu – GLM-4.5-Air (106B), DeepSeek-R1-Distill (32.8B), Seed-OSS (36B), Devstral (24B) und Qwen3-Coder (30.5B) –, die aus einem separaten Coding-Agent-Benchmark stammten, den ich bereits auf derselben Field ausgeführt hatte (gleiche GPU, gleicher Tarif, gleiche Kostentoken-Methode, aber echte mehrstufige Agentenaufgaben anstelle einer dedizierten 240-Sekunden-Generationsschleife – vermerkt, wo es darauf ankommt, in den Vorbehalten unten). Acht Modelle, ein Maßstab:
Und die Cloud-Referenz, an der ich gemessen habe (Listenpreise, Juni 2026): Ein gehostetes Flash-Klasse-Modell – Gemini 2.5 Flash, GPT-4o-mini – läuft ungefähr 0,60 $ professional 1 Mio. Ausgabetoken (~0,55 €); Die günstigste Stufe (Gemini 3.1 Flash-Lite) ist verfügbar 0,40 $.
Die Überraschung
Fünf der acht sind günstiger als die Cloud-Referenz. Drei sind es nicht – und die drei, die es nicht sind, sind es nicht die drei, die Sie nach Parameteranzahl auswählen würden.
GLM-4.5-Air ist das größte Modell auf der Liste, 106B Parameter, und es kostet 1.040 €/1 Mio. – wirklich mehr als die Cloud-API, Strom allein, ohne einen Cent des GPU-Kaufpreises. Dieser Teil entspricht der ursprünglichen Instinct: großes Modell, langsam, teuer.
Aber DeepSeek-R1-Distill ist kaum ein Drittel so groß wie GLM – 32,8 Milliarden Parameter – und das ist es am meisten teures Modell auf der gesamten Liste, bei 1,526 €/1 Mio. €. Es verbraucht weniger Strom als gemma3:27b (155 W gegenüber 283 W) – und ist es immer noch am teuersten professional Token aller getesteten Modelle .
Ein methodischer Hinweis, der hier wichtig ist, im Vorfeld und nicht im Verborgenen: Die drei Gemma-Modelle wurden auf einem speziellen 240-Sekunden-Benchmark mit kontinuierlicher Era gemessen, den ich für dieses Stück erstellt habe. Die anderen fünf – einschließlich DeepSeek-R1-Distill – stammen aus einem früheren, separaten Benchmark echter mehrstufiger Coding-Agent-Aufgaben (Instrument-Aufrufe, Multi-Flip-Argumentation) auf derselben GPU und demselben Tarif unter Verwendung der identischen Kosten-Ausgabe-Token-Formel. Dieser Unterschied ist der Grund dafür, dass DeepSeek so aussieht, wie es aussieht: Es ist Roherzeugungsgeschwindigkeit bei aktiver Token-Produktion sind es respektable 6,7 Token/Sek. Der Zähler berechnet jedoch nicht die reine Erzeugungsgeschwindigkeit. Der Zähler berechnet die auf der Karte gespeicherte Zeit, und DeepSeek – ein Modell, das auf logischen Überlegungen basiert – verbringt die meiste Zeit damit, zwischen den Generationen zu beraten und nicht zu generieren. Es ist effektive Lieferrate(Ausgabe-Tokens ÷ Gesamtlaufzeit, inklusive Überlegung) klappt 3,7 Token/Sek der niedrigste aller getesteten Modelle – deutlich unter den effektiven 7,1 von Seed-OSS und 5,0 von GLM. Das ist es, was der Preis tatsächlich abbildet.
Größe struggle nie der Mechanismus. Die effektive Geschwindigkeit struggle – und die effektive Geschwindigkeit ist nicht der Wert, mit dem diese Modelle normalerweise gemessen werden.
Der Mechanismus
Jeder Token kostet Watt ÷ Durchsatz.Das ist die ganze Gleichung – der Trick besteht darin, die richtige Durchsatzzahl zu verwenden:
gemma3:1b ist schnell (136 tok/s) und leicht (154 W) – günstig auf beiden Achsen, insgesamt am günstigsten. Devstral zieht von allen getesteten Modellen die meiste Leistung (320 W), bleibt aber im Mittelfeld, da es immer noch recht schnell ist. Für die drei speziell entwickelten Gemma-Modelle: Roherzeugungsgeschwindigkeit Ist Die Zahl, die den Preis festlegt – Watt ÷ Uncooked Tok/s – rekonstruiert das Kostenverhältnis quick genau. Für die fünf Agenten-Benchmark-Modelle ist die Zahl, die den Preis festlegt effektiver Wanduhrdurchsatz nicht die reine Erzeugungsgeschwindigkeit, mit der sie normalerweise angegeben würden – und nach dieser Zahl sind Seed-OSS (7,1 tok/s effektiv), GLM-4.5-Air (5,0) und DeepSeek-R1-Distill (3,7) die drei langsamsten getesteten Modelle, und zwar genau in der Reihenfolge ihrer Kosten. Keiner von ihnen hat einen ungewöhnlichen Stromverbrauch (eigentlich 141–186 W). untere als mehrere günstigere Modelle); Sie sind nur langsam, wenn man Werkzeugaufrufe und Argumentationslücken berücksichtigt, und ein Modell, das langsam ist, zahlt sich für jede Sekunde aus, in der es die Karte in der Hand hält, unabhängig von der Parameteranzahl.
Was ich *nicht* behaupte
Dies ist der Teil, der es ehrlich hält, additionally werde ich die Ränder ganz offen sagen:
· Dabei handelt es sich lediglich um GPU-Strom – gemessen, marginal und winzig.Ein vollständiger Lauf rundet auf den Bruchteil eines Cents. Ich messe weder CPU noch DRAM (RAPL struggle auf diesem Host nicht lesbar, daher wurden diese als Null zurückgegeben), und das tue ich ausdrücklich nicht Ich zähle den Kaufpreis der GPU, den Leerlaufverbrauch, die Kühlung oder meine Zeit. Die Zahlen für €/1 Mio. sind die Grenzenergierate nützlich für „Welches Modell ist günstiger, um es weiterhin zu erzeugen“, nicht für die Gesamtbetriebskosten.
· Die tatsächlichen Kosten für lokal sind die GPU, die Sie gekauft haben, nicht die Wattzahl. Ein 3090 amortisiert sich nur bei hoher, gleichmäßiger Auslastung. Eine Field, die ein paar Minuten am Tag ausgelastet ist, zahlt hauptsächlich für ungenutztes Silizium, und keine Stromzahl erfasst das. Die Grenzenergielinse ist ehrlich über ihren eigenen Anwendungsbereich: Es kommt auf den Boden an, nicht auf die Rechnung.
· Zwei Messmethoden (siehe „Die Überraschung“ oben, warum das wichtig ist). Die drei Gemma-Modelle: ein dedizierter 240-Sekunden-Benchmark für die nachhaltige Era. Die anderen fünf: ein separater echter Coding-Agent-Benchmark, dieselbe Kosten-Token-Formel, aber wirksam Der Durchsatz beträgt eher den Taktgeber als die bloße Generierungsgeschwindigkeit – was wohl repräsentativer dafür ist, wie diese Modelle tatsächlich genutzt werden, nicht weniger, da echte Agenten-Arbeitslasten Toolaufrufe und Überlegungen beinhalten, die eine reine Generierungsschleife niemals tun würde.
·Eine GPU, eine Engine, quantisierte GGUF-Gewichte.Ihr Tarif, Ihr Modell, Ihre Chargengröße, Ihre Quantisierung und Ihre Karte bewegen hier jede Nummer. Der Tisch ist Mein Kasten; Die Methode ist der übertragbare Teil.
Betrachten Sie additionally die absoluten Euro als Veranschaulichung und die Kind Als Ergebnis: Die Kosten professional Token verfolgen die effektive Liefergeschwindigkeit, und das verfolgt die Parameteranzahl nicht in der erwarteten Weise.
Das Essen zum Mitnehmen
Wählen Sie das kleinste und schnellste Modell, das Ihren Qualitätsmaßstäben gerecht wird – hier zahlt sich „lokal“ tatsächlich aus, und zwar bei weitem, und es hat nichts mit der Auswahl eines kleinen Modells zu tun Weil es ist klein. Qwen3-Coder ist mit 30,5B professional Token günstiger als gemma4:26b, und gemma3:27b mit 27B übertrifft jedes Argumentationsmodell auf der Liste, obwohl es sich um ein einfaches dichtes Modell ohne besondere Effizienztricks handelt. Die Variable, die zählt, sind die professional Sekunde gelieferten Token, Punkt – nicht die rohe Generationsgeschwindigkeit, mit der ein Modell normalerweise bewertet wird – und die einzige Möglichkeit, sie für Ihr Modell und Ihre Field zu ermitteln, besteht darin, sie zu messen.
Das von mir verwendete Instrument ist HomeLab-Monitor– Open Supply, MIT, ein Container – und der oben genannte Run-Pricing ist genau das, was die Registerkarte „Experimente“ standardmäßig leistet:
Fügen Sie Ihren GPU-Host hinzu, prägen Sie einen Schlüssel und Ihre nächsten Benchmark-Preise selbst – in der Währung, die Sie tatsächlich konfiguriert haben, was es wert ist, überprüft zu werden, bevor Sie die Zahl veröffentlichen.
Wenn Sie additionally über die API nach dem lokalen Modell greifen, kennen Sie dann tatsächlich die Anzahl professional Token in der richtigen Währung – oder gehen Sie, wie ich, einfach davon aus, dass die GPU sie kostenlos macht?