Ollama-Modelle evaluieren

Was dieser Artikel über Ollama-Evaluation behandelt

• Warum Modelle evaluiert werden sollten.
• Welche Metriken und Benchmarks es gibt.
• Wie man eigene Testaufgaben erstellt.
• Wie man Modelle automatisch vergleicht.
• Tipps für faire und aussagekräftige Vergleiche.

Einleitung: Ollama-Modelle evaluieren

Ollama bietet viele Modelle, aber nicht jedes ist für jede Aufgabe gleich gut. Eines mag stark in Coding sein, ein anderes in Mathematik oder mehrsprachigen Zusammenfassungen. Wer Modelle regelmässig evaluiert, findet schneller das passende Modell für den eigenen Anwendungsfall und vermeidet, auf subjektiven Eindrücken zu basieren.

Dieser Artikel zeigt, wie man Ollama-Modelle systematisch bewertet, welche Metriken sinnvoll sind und wie man eigene Testaufgaben aufbaut.

Wichtige Begriffe

• Evaluation: Bewertung eines Modells.
• Benchmark: Standardisierter Test zur Modellbewertung.
• Metrik: Messgrösse für eine bestimmte Eigenschaft.
• Perplexity: Mass für die Modellunsicherheit.
• BLEU / ROUGE: Metriken für generierte Texte.
• Human Evaluation: Manuelle Bewertung durch Personen.
• Few-Shot: Wenige Beispiele im Prompt.
• Zero-Shot: Keine Beispiele im Prompt.

Warum Modelle evaluieren?

• Nicht jedes Modell ist für jede Aufgabe geeignet.
• Grössere Modelle sind nicht immer besser.
• Quantisierungen verändern die Qualität unterschiedlich.
• Für produktive Anwendungen braucht es reproduzierbare Ergebnisse.
• Man vergleicht schneller Alternativen.

Bewertungsdimensionen

Allgemeines Wissen

Fragen aus Geschichte, Geografie, Naturwissenschaften und Allgemeinbildung.

Coding

Programmieraufgaben, Code-Erklärungen, Refactoring und Bugfixes.

Mathematik und Logik

Rechenaufgaben, Textgleichungen, logische Rätsel.

Mehrsprachigkeit

Übersetzungen, Zusammenfassungen und Antworten in verschiedenen Sprachen.

Fakten und Halluzinationen

Prüfung, ob das Modell erfundene Angaben macht.

Geschwindigkeit und Ressourcen

Tokens pro Sekunde, RAM- und VRAM-Verbrauch, Ladezeit.

Bekannte Benchmarks

• MMLU: Allgemeines Wissen über viele Fächer.
• HumanEval: Coding-Aufgaben.
• GSM8K: Mathematische Textaufgaben.
• TruthfulQA: Erkennung von Fehlinformationen.
• MT-Bench: Multi-turn Konversationen.

Oft lassen sich diese Benchmarks mit lokalen Tools wie lm-evaluation-harness ausführen.

Eigene Testaufgaben erstellen

Eine einfache Aufgabensammlung für den eigenen Anwendungsfall:

[
  {
    "id": 1,
    "category": "coding",
    "prompt": "Schreibe eine Python-Funktion, die die ersten n Primzahlen zurückgibt.",
    "expected": ["def primes(n):", "for", "return"]
  },
  {
    "id": 2,
    "category": "summarization",
    "prompt": "Fasse den folgenden Text in drei Sätzen zusammen: ...",
    "expected": ["main", "topic"]
  }
]

Automatisierte Evaluation in Python

import ollama
import json

def ask(model, prompt):
    response = ollama.generate(model=model, prompt=prompt)
    return response["response"]

def evaluate(model, tasks):
    results = []
    for task in tasks:
        answer = ask(model, task["prompt"])
        score = check_keywords(answer, task["expected"])
        results.append({
            "id": task["id"],
            "category": task["category"],
            "score": score
        })
    return results

def check_keywords(answer, expected):
    matches = [kw for kw in expected if kw.lower() in answer.lower()]
    return len(matches) / len(expected)

tasks = json.load(open("tasks.json"))
print(evaluate("llama3.1", tasks))

Modellvergleich

models = ["llama3.1", "qwen2.5:14b", "mistral"]
for model in models:
    scores = evaluate(model, tasks)
    avg = sum(r["score"] for r in scores) / len(scores)
    print(f"{model}: {avg:.2f}")

Metriken für generierte Texte

• Exact Match: Antwort stimmt exakt mit der erwarteten Antwort überein.
• Keyword Match: Erwartete Begriffe kommen in der Antwort vor.
• ROUGE: Überschneidung von N-Grammen.
• BERTScore: Semantische Ähnlichkeit der Antworten.
• LLM-as-a-Judge: Ein stärkeres Modell bewertet die Antworten.

Geschwindigkeit messen

import time

start = time.time()
answer = ask("llama3.1", prompt)
end = time.time()

print(f"Dauer: {end - start:.2f} s")
print(f"Tokens pro Sekunde: {len(answer.split()) / (end - start):.1f}")

Genauere Token-Messungen liefert ollama ps oder die API-Response mit eval_count und eval_duration.

Tipps für faire Vergleiche

• Gleiche Prompts für alle Modelle.
• Gleiche Temperatur, meist niedrig wie 0.1.
• Gleiche Hardware und Softwareumgebung.
• Mehrere Durchläufe pro Aufgabe.
• Eigene Aufgaben aus der realen Nutzung.
• Quantisierung und Tag dokumentieren.
• Auch Geschwindigkeit und Ressourcen erfassen.

Typische Stolpersteine

• Unterschiedliche Prompts: Resultate nicht vergleichbar.
• Zu hohe Temperatur: Antworten variieren stark.
• Zu wenige Testaufgaben: Resultate nicht aussagekräftig.
• Nur auf Benchmarks verlassen: Echte Anwendung kann anders aussehen.
• Hardware beeinflusst Messungen: Langsamere GPU verfälscht Vergleich.
• Halluzinationen nicht prüfen: Faktische Fehler bleiben unentdeckt.

Weiterführende Links und Infos

• BotServ.de Ollama Performance
• BotServ.de Ollama Befehle
• BotServ.de Ollama Modell-Lebenszyklus
• BotServ.de Lokale Coding-Modelle

FAQ: Ollama-Evaluation

Muss ich Modelle selbst evaluieren? Nicht immer, aber für eigene Anwendungsfälle ist es sehr empfehlenswert.

Welche Benchmarks sind am wichtigsten? Das hängt vom Anwendungsfall ab: MMLU für Wissen, HumanEval für Coding, GSM8K für Mathematik.

Kann ich zwei Modelle gleichzeitig testen? Ja, aber nicht auf derselben GPU, wenn beide gross sind.

Wie viele Testfälle brauche ich? Besser 50 als 5, aber schon einige dutzend eigene Aufgaben helfen.

Was ist LLM-as-a-Judge? Ein anderes Modell bewertet die Qualität der Antworten.

Quellen und weiterführende Literatur

• EleutherAI lm-evaluation-harness: https://github.com/EleutherAI/lm-evaluation-harness
• HELM: https://crfm.stanford.edu/helm/
• BigBench: https://github.com/google/BIG-bench
• MMLU: https://paperswithcode.com/dataset/mmlu

Zusammenfassung: Ollama-Modelle evaluieren

Evaluation ist der beste Weg, das richtige Ollama-Modell für eine Aufgabe zu finden. Eigene Testaufgaben, bekannte Benchmarks und einfache Metriken wie Keyword-Match oder Tokens pro Sekunde liefern objektive Vergleiche. Wichtig sind gleiche Bedingungen, niedrige Temperaturen und eine gute Abdeckung der eigenen Anwendungsfälle. Wer regelmässig evaluiert, kann gezielt zwischen Modellgrössen, Quantisierungen und Architekturen wählen.