Ollama-Modelle benchmarken
Was dieser Artikel über Ollama-Benchmarks behandelt
- Warum Benchmarks wichtig sind.
- Welche Metriken gemessen werden.
- Wie man Tokens pro Sekunde ermittelt.
- Wie man VRAM und RAM misst.
- Vergleich von Modellen mit unterschiedlicher Quantisierung.
Einleitung: Ollama-Modelle benchmarken
Lokale Modelle gibt es in vielen Grössen, Quanten und Architekturen. Nicht jedes Modell läuft auf jeder Hardware gleich schnell oder liefert dieselbe Qualität. Benchmarks helfen, zu messen, welches Modell für einen bestimmten Anwendungsfall und eine bestimmte Hardware passt. Wichtig sind Geschwindigkeit, Speicherverbrauch und Antwortqualität.
Dieser Artikel zeigt, wie man Ollama-Modelle einfach selbst benchmarkt.
Wichtige Begriffe
- Throughput: Anzahl Tokens pro Sekunde.
- Latency: Zeit bis zur ersten Antwort.
- TTFT: Time To First Token.
- VRAM: Videospeicher der GPU.
- Quantisierung: Reduktion der Modellpräzision.
- Prompt-Tokens: Tokens im Eingabetext.
- Completion-Tokens: Tokens im Antworttext.
- Perplexity: Mass für Modellunsicherheit.
Was man messen sollte
- Tokens pro Sekunde (total): Gesamtgeschwindigkeit.
- Prompt-Eval-Zeit: Zeit, den Kontext zu verarbeiten.
- Eval-Zeit: Zeit, Antwort-Tokens zu generieren.
- VRAM-Verbrauch: Wird genug VRAM frei?
- RAM-Verbrauch: Bei rein CPU-basiertem Betrieb.
- Qualität: Antwort auf vorbereitete Fragen prüfen.
Einfacher Python-Benchmark
import requests
import time
url = "http://localhost:11434/api/generate"
prompt = "Erkläre kurz, was ein neuronales Netz ist."
model = "llama3.1"
payload = {
"model": model,
"prompt": prompt,
"stream": False,
"options": {
"num_predict": 100
}
}
start = time.time()
response = requests.post(url, json=payload)
end = time.time()
data = response.json()
duration = end - start
tokens = data.get("eval_count", 0)
tps = tokens / duration if duration > 0 else 0
print(f"Dauer: {duration:.2f} s")
print(f"Tokens: {tokens}")
print(f"Tokens/s: {tps:.2f}")
print(f"VRAM: prüfe mit nvidia-smi")Antwort auswerten
print(data["response"])Mehrere Modelle vergleichen
models = ["llama3.1", "qwen2.5:7b", "mistral:7b"]
prompt = "Was ist Docker?"
for model in models:
payload = {
"model": model,
"prompt": prompt,
"stream": False,
"options": {"num_predict": 100}
}
start = time.time()
r = requests.post(url, json=payload)
end = time.time()
data = r.json()
duration = end - start
tokens = data.get("eval_count", 0)
print(f"{model}: {tokens/duration:.2f} tokens/s")Prompt-Eval vs. Completion-Eval
Ollama liefert im Modus stream: false Felder wie prompt_eval_count und eval_count. Daraus lassen sich gezieltere Kennzahlen berechnen:
- prompt eval time: Zeit für den Kontext.
- eval time: Zeit für die Antwort.
VRAM messen
nvidia-smi --query-gpu=memory.used --format=csv -l 1Oder für AMD:
rocm-smi --showmeminfo vramTestfragen für Qualität
Benchmarks zur Geschwindigkeit sagen noch nichts über Qualität. Vorbereitete Fragen helfen:
- Zusammenfassung eines Textes.
- Erklärung eines Konzepts.
- Übersetzung.
- Code-Generierung.
- Logisches Rätsel.
Quantisierung vergleichen
| Quant | Tokens/s | Qualität | VRAM |
|---|---|---|---|
| Q4_0 | hoch | niedriger | wenig |
| Q4_K_M | hoch | gut | wenig |
| Q5_K_M | mittel | sehr gut | mittel |
| Q8_0 | niedriger | hoch | viel |
Empfehlung: Die kleinste Quantisierung suchen, bei der die Qualität noch ausreicht.
Automatisierter Benchmark
import json
import time
import requests
def benchmark(model, prompt, num_predict=100):
url = "http://localhost:11434/api/generate"
start = time.time()
r = requests.post(url, json={
"model": model,
"prompt": prompt,
"stream": False,
"options": {"num_predict": num_predict}
})
end = time.time()
data = r.json()
return {
"model": model,
"duration": end - start,
"tokens": data.get("eval_count", 0),
"tps": data.get("eval_count", 0) / (end - start)
}
results = [benchmark(m, "Erkläre KI in drei Sätzen.") for m in ["llama3.1", "qwen2.5"]]
print(json.dumps(results, indent=2))Tipps
- Vor jedem Lauf Ollama neu starten, damit keine alten Daten den Cache beeinflussen.
- Denselben Prompt und dieselbe
num_predictverwenden. - Mehrere Läufe durchführen und Mittelwert bilden.
- Temperatur auf 0 setzen, um reproduzierbare Ergebnisse zu erhalten.
- Hardware-Temperatur beobachten, um Drosselung zu vermeiden.
Typische Stolpersteine
- Erster Lauf ist langsamer: Modell muss geladen werden.
- Unterschiedliche Prompt-Länge: Beeinflusst Zeiten.
- Streaming: Synchrones Messen schwierig.
- GPU-Drosselung: Nach langer Last langsamer.
- Falsche Quantisierung: Modell passt nicht auf VRAM.
- Cache-Effekte: Modell bleibt im Speicher.
Weiterführende Links und Infos
- BotServ.de Ollama Performance
- BotServ.de Ollama Quantisierung Praxis
- BotServ.de Ollama Modell-Aktualisierung
- BotServ.de Ollama Evaluation
FAQ: Ollama-Benchmarks
Was ist eine gute Tokens-pro-Sekunde-Zahl? Das hängt vom Modell und der Hardware ab. 10-30 tokens/s sind für lokale 7B-Modelle typisch.
Soll ich immer die höchste Quantisierung nehmen? Nein, wenn die Qualität für den Einsatzzweck ausreicht, ist eine niedrigere Quantisierung schneller.
Wie messe ich VRAM?
Mit nvidia-smi oder rocm-smi während der Ausführung.
Warum ist der zweite Lauf schneller? Weil das Modell bereits im Speicher ist.
Kann ich Qualität automatisch benchmarken? Nur eingeschränkt. Am besten vorbereitete Fragen und manuelle Bewertung.
Quellen und weiterführende Literatur
- Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
- llama.cpp Benchmarks: https://github.com/ggerganov/llama.cpp/blob/master/examples/perplexity/README.md
- Tokens zählen: https://platform.openai.com/tokenizer
Zusammenfassung: Ollama-Modelle benchmarken
Benchmarks sind unverzichtbar, um passende Ollama-Modelle für eigene Hardware und Anwendungsfälle zu finden. Tokens pro Sekunde, TTFT, VRAM- und RAM-Verbrauch sowie Antwortqualität sollten gemessen werden. Mit einfachen Python-Skripten lassen sich Modelle und Quantisierungen systematisch vergleichen. Wer mehrere Läufe mit gleichem Prompt durchführt, bekommt reproduzierbare Ergebnisse und kann gezielt die beste Balance aus Geschwindigkeit und Qualität wählen.