Was macht Regex vs. LLM für strukturierte Textanalyse?
Ein praktisches Entscheidungsframework zum Parsen von strukturiertem Text (Tests, Formulare, Rechnungen, Dokumente). Die Kernidee: Regex erledigt 95–98 % der Fälle kostengünstig und deterministisch. Hebe dir teure LLM-Aufrufe für die verbleibenden Randfälle auf.
Wann aktivieren
- Strukturierten Text mit sich wiederholenden Mustern parsen (Fragen, Formulare, Tabellen)
- Entscheidung zwischen Regex und LLM für Textextraktion
- Hybride Pipelines bauen, die beide Ansätze kombinieren
- Kosten-/Genauigkeitsabwägungen in der Textverarbeitung optimieren
Entscheidungsframework
Ist das Textformat konsistent und wiederholend?
├── Ja (>90 % folgt einem Muster) → Beginne mit Regex
│ ├── Regex schafft >95 % → Fertig, kein LLM nötig
│ └── Regex schafft <95 % → LLM nur für Randfälle hinzufügen
└── Nein (freie Form, stark variierend) → LLM direkt verwenden
Architekturmuster
Quelltext
│
▼
[Regex-Parser] ─── Extrahiert Struktur (95–98 % Genauigkeit)
│
▼
[Textbereiniger] ─── Entfernt Rauschen (Markierungen, Seitenzahlen, Artefakte)
│
▼
[Konfidenz-Scorer] ─── Markiert Extraktionen mit niedriger Konfidenz
│
├── Hohe Konfidenz (≥0,95) → Direkte Ausgabe
│
└── Niedrige Konfidenz (<0,95) → [LLM-Validator] → Ausgabe
Implementierung
1. Regex-Parser (erledigt den Großteil)
import re
from dataclasses import dataclass
@dataclass(frozen=True)
class ParsedItem:
id: str
text: str
choices: tuple[str, ...]
answer: str
confidence: float = 1.0
def parse_structured_text(content: str) -> list[ParsedItem]:
"""Strukturierten Text mit Regex-Mustern parsen."""
pattern = re.compile(
r"(?P<id>\d+)\.\s*(?P<text>.+?)\n"
r"(?P<choices>(?:[A-D]\..+?\n)+)"
r"Answer:\s*(?P<answer>[A-D])",
re.MULTILINE | re.DOTALL,
)
items = []
for match in pattern.finditer(content):
choices = tuple(
c.strip() for c in re.findall(r"[A-D]\.\s*(.+)", match.group("choices"))
)
items.append(ParsedItem(
id=match.group("id"),
text=match.group("text").strip(),
choices=choices,
answer=match.group("answer"),
))
return items
2. Konfidenz-Scoring
Markiere Elemente, die eine LLM-Überprüfung benötigen:
@dataclass(frozen=True)
class ConfidenceFlag:
item_id: str
score: float
reasons: tuple[str, ...]
def score_confidence(item: ParsedItem) -> ConfidenceFlag:
"""Scored die Extraktionskonfidenz und markiert Probleme."""
reasons = []
score = 1.0
if len(item.choices) < 3:
reasons.append("few_choices")
score -= 0.3
if not item.answer:
reasons.append("missing_answer")
score -= 0.5
if len(item.text) < 10:
reasons.append("short_text")
score -= 0.2
return ConfidenceFlag(
item_id=item.id,
score=max(0.0, score),
reasons=tuple(reasons),
)
def identify_low_confidence(
items: list[ParsedItem],
threshold: float = 0.95,
) -> list[ConfidenceFlag]:
"""Gibt Elemente unterhalb des Konfidenz-Schwellenwerts zurück."""
flags = [score_confidence(item) for item in items]
return [f for f in flags if f.score < threshold]
3. LLM-Validator (nur Randfälle)
def validate_with_llm(
item: ParsedItem,
original_text: str,
client,
) -> ParsedItem:
"""Nutzt LLM zur Korrektur von Extraktionen mit niedriger Konfidenz."""
response = client.messages.create(
model="claude-haiku-4-5-20251001", # Günstigstes Modell für Validierung
max_tokens=500,
messages=[{
"role": "user",
"content": (
f"Extrahiere die Frage, die Antwortmöglichkeiten und die Antwort aus diesem Text.\n\n"
f"Text: {original_text}\n\n"
f"Aktuelle Extraktion: {item}\n\n"
f"Gib korrigiertes JSON zurück, falls nötig, oder 'CORRECT', wenn es korrekt ist."
),
}],
)
# LLM-Antwort parsen und korrigiertes Element zurückgeben...
return corrected_item
4. Hybride Pipeline
def process_document(
content: str,
*,
llm_client=None,
confidence_threshold: float = 0.95,
) -> list[ParsedItem]:
"""Vollständige Pipeline: Regex -> Konfidenzprüfung -> LLM für Randfälle."""
# Schritt 1: Regex-Extraktion (erledigt 95–98 %)
items = parse_structured_text(content)
# Schritt 2: Konfidenz-Scoring
low_confidence = identify_low_confidence(items, confidence_threshold)
if not low_confidence or llm_client is None:
return items
# Schritt 3: LLM-Validierung (nur für markierte Elemente)
low_conf_ids = {f.item_id for f in low_confidence}
result = []
for item in items:
if item.id in low_conf_ids:
result.append(validate_with_llm(item, content, llm_client))
else:
result.append(item)
return result
Metriken aus der Praxis
Aus einer Produktions-Pipeline zum Parsen von Quizfragen (410 Items):
| Metrik | Wert |
|---|---|
| Regex-Erfolgsrate | 98,0 % |
| Elemente mit niedriger Konfidenz | 8 (2,0 %) |
| Benötigte LLM-Aufrufe | ~5 |
| Kosteneinsparung im Vergleich zu reinem LLM | ~95 % |
| Testabdeckung | 93 % |
Best Practices
- Beginne mit Regex – selbst ein unvollkommener Regex gibt dir eine Basis, die du verbessern kannst
- Nutze Konfidenz-Scoring, um programmatisch zu identifizieren, was LLM-Hilfe braucht
- Verwende das günstigste LLM für die Validierung (Modelle der Haiku-Klasse reichen aus)
- Verändere geparste Elemente niemals direkt – gib neue Instanzen aus Bereinigungs- und Validierungsschritten zurück
- TDD funktioniert gut für Parser – schreibe zuerst Tests für bekannte Muster, dann für Randfälle
- Protokolliere Metriken (Regex-Erfolgsrate, Anzahl LLM-Aufrufe), um die Pipeline-Gesundheit zu überwachen
Anti-Patterns (vermeiden)
- Allen Text an ein LLM senden, wenn Regex >95 % der Fälle abdeckt (teuer und langsam)
- Regex für freie, stark variierende Texte verwenden (LLM ist hier besser)
- Konfidenz-Scoring überspringen und hoffen, dass Regex „einfach funktioniert“
- Geparste Objekte während Bereinigungs-/Validierungsschritten verändern
- Randfälle nicht testen (fehlerhafte Eingaben, fehlende Felder, Kodierungsprobleme)
Wann verwenden
- Quiz-/Prüfungsfragen parsen
- Formulardaten extrahieren
- Rechnungs-/Belegverarbeitung
- Dokumentenstruktur parsen (Kopfzeilen, Abschnitte, Tabellen)
- Jeder strukturierte Text mit sich wiederholenden Mustern, bei dem Kosten eine Rolle spielen