Buch SFT Pipeline
Ein vollständiges System zur Umwandlung von Büchern in SFT-Datensätze und zum Trainieren von Style-Transfer-Modellen. Diese Fähigkeit lehrt die Pipeline vom rohen ePub bis zu einem Modell, das in der Stimme eines beliebigen Autors schreibt.
Wann aktivieren
Aktivieren Sie diese Fähigkeit, wenn:
- Feintuning-Datensätze aus literarischen Werken erstellt werden
- Autorenstimmen- oder Style-Transfer-Modelle erstellt werden
- Trainingsdaten für Tinker oder ähnliche SFT-Plattformen vorbereitet werden
- Textsegmentierungspipelines für Langform-Inhalte entworfen werden
- Kleine Modelle (8B oder weniger) mit begrenzten Daten trainiert werden
Kernkonzepte
Die drei Säulen der Buch-SFT
1. Intelligente Segmentierung Textblöcke müssen semantisch kohärent sein. Das Unterbrechen mitten im Satz lehrt das Modell, fragmentierte Ausgaben zu produzieren. Ziel: 150-400 Wörter pro Block, immer an natürlichen Grenzen.
2. Vielfältige Instruktionsgenerierung Verwenden Sie mehrere Prompt-Vorlagen und System-Prompts, um Overfitting zu verhindern. Ein einziger Prompt-Stil führt zu Auswendiglernen. Verwenden Sie 15+ Prompt-Vorlagen mit 5+ System-Prompts.
3. Stil über Inhalt Das Ziel ist es, den Rhythmus und die Vokabularmuster des Autors zu lernen, nicht Handlungen auswendig zu lernen. Synthetische Instruktionen beschreiben, was passiert, ohne den Text zu zitieren.
Pipeline-Architektur
┌─────────────────────────────────────────────────────────────────┐
│ ORCHESTRATOR AGENT │
│ Koordiniert Pipeline-Phasen, verwaltet Zustand, behandelt Fehler│
└──────────────────────┬──────────────────────────────────────────┘
│
┌───────────────┼───────────────┬───────────────┐
▼ ▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ EXTRAKTION │ │ SEGMENTIERUNG│ │ INSTRUKTION │ │ DATENSATZ- │
│ AGENT │ │ AGENT │ │ AGENT │ │ ERSTELLER │
│ ePub → Text │ │ Text → Blöcke│ │ Blöcke → │ │ Paare → │
│ │ │ 150-400 Wörter│ │ Prompts │ │ JSONL │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘
│
┌───────────────┴───────────────┐
▼ ▼
┌──────────────┐ ┌──────────────┐
│ TRAINING │ │ VALIDIERUNG │
│ AGENT │ │ AGENT │
│ LoRA auf │ │ KI-Erkennung │
│ Tinker │ │ Originalität │
└──────────────┘ └──────────────┘
Phase 1: Textextraktion
Kritische Regeln
- Immer ePub gegenüber PDF bevorzugen - OCR-Fehler werden zu erlernten Mustern
- Absatzweise Extraktion verwenden - Aus
<p>-Tags extrahieren, um Brüche zu erhalten - Vor-/Nachwort entfernen - Copyright und Inhaltsverzeichnis verunreinigen den Datensatz
# Text aus ePub-Absätzen extrahieren
from epub2 import EPub
from bs4 import BeautifulSoup
def extract_epub(path):
book = EPub(path)
chapters = []
for item in book.flow:
html = book.get_chapter(item.id)
soup = BeautifulSoup(html, 'html.parser')
paragraphs = [p.get_text().strip() for p in soup.find_all('p')]
chapters.append('\n\n'.join(p for p in paragraphs if p))
return '\n\n'.join(chapters)
Phase 2: Intelligente Segmentierung
Kleinere Blöcke + Überlappung
Kleinere Blöcke (150-400 Wörter) erzeugen mehr Trainingsbeispiele und einen besseren Style-Transfer als größere Blöcke (250-650).
def segment(text, min_words=150, max_words=400):
paragraphs = text.split('\n\n')
chunks, buffer, buffer_words = [], [], 0
for para in paragraphs:
words = len(para.split())
if buffer_words + words > max_words and buffer_words >= min_words:
chunks.append('\n\n'.join(buffer))
# Letzten Absatz für Überlappung behalten
buffer = [buffer[-1], para] if buffer else [para]
buffer_words = sum(len(p.split()) for p in buffer)
else:
buffer.append(para)
buffer_words += words
if buffer:
chunks.append('\n\n'.join(buffer))
return chunks
Erwartete Ergebnisse
Für ein Buch mit 86.000 Wörtern:
- Alte Methode (250-650 Wörter): ~150 Blöcke
- Neue Methode (150-400 + Überlappung): ~300 Blöcke
- Mit 2 Varianten pro Block: 600+ Trainingsbeispiele
Phase 3: Vielfältige Instruktionsgenerierung
Die entscheidende Erkenntnis
Die Verwendung einer einzigen Prompt-Vorlage führt zu Auswendiglernen. Vielfältige Vorlagen lehren den zugrunde liegenden Stil.
SYSTEM_PROMPTS = [
"Du bist ein erfahrener kreativer Schriftsteller, der spezifische literarische Stile nachahmen kann.",
"Du bist ein literarischer Schriftsteller mit tiefem Wissen über klassische Prosastile.",
"Du bist ein kreativer Schriftsteller, der sich darauf versteht, unverwechselbare Autorenstimmen nachzuahmen.",
"Du schreibst Prosa, die die Essenz der modernistischen Literatur einfängt.",
"Du bist ein talentierter Schriftsteller, der klassische amerikanische Autoren kanalisieren kann.",
]
PROMPT_TEMPLATES = [
"Schreibe eine Passage im Stil von {author}: {desc}",
"Kanalisiere {author}s Stimme, um zu schreiben über: {desc}",
"In {author}s unverwechselbarem Prosastil beschreibe: {desc}",
"Schreibe diese Szene so, wie {author} es getan hätte: {desc}",
"Mit {author}s repetitiver Technik beschreibe: {desc}",
"Fange den Rhythmus von {author} in dieser Passage ein: {desc}",
"Schreibe wie {author}: {desc}",
"In der Stimme von {author} schreibe: {desc}",
"Dies ist eine literarische Übung. Schreibe wie {author}: {desc}",
"Kannst du in {author}s Stil schreiben? {desc}",
]
Instruktionsgenerierung
INSTRUCTION_PROMPT = """Beschreibe, was in diesem Auszug passiert, in 2-3 Sätzen.
Konzentriere dich auf: anwesende Charaktere, Handlungen, Emotionen, Schauplatz.
Zitiere den Text NICHT direkt.
Auszug:
{text}
"""
# Verwende ein schnelles, günstiges LLM (z.B. Gemini Flash)
instruction = llm_call(INSTRUCTION_PROMPT.format(text=chunk))
Phase 4: Datensatzerstellung
Nachrichtenformat
{
"messages": [
{"role": "system", "content": "Du bist ein erfahrener kreativer Schriftsteller..."},
{"role": "user", "content": "Schreibe im Stil von Autor: Szenenbeschreibung..."},
{"role": "assistant", "content": "Der eigentliche Buchtext aus dem Block..."}
]
}
Mehrere Varianten pro Block
def build_examples(chunk, instruction, author, variants=2):
examples = []
for i in range(variants):
system = SYSTEM_PROMPTS[i % len(SYSTEM_PROMPTS)]
template = PROMPT_TEMPLATES[(chunk.id + i) % len(PROMPT_TEMPLATES)]
user = template.format(author=author, desc=instruction)
examples.append({"messages": [
{"role": "system", "content": system},
{"role": "user", "content": user},
{"role": "assistant", "content": chunk.text}
]})
return examples
Phase 5: LoRA-Training auf Tinker
Konfiguration
CONFIG = {
"model_name": "Qwen/Qwen3-8B-Base", # Base, nicht instruct
"lora_rank": 32, # 352MB Adapter
"learning_rate": 5e-4, # Höher für LoRA
"batch_size": 4,
"epochs": 3,
}
Warum das Basismodell?
Verwenden Sie Base-Modelle (vortrainiert), nicht Instruction-getunte Versionen:
- Basismodelle sind formbarer für neue Stile
- Instruction-Modelle haben Muster, die dem Überschreiben widerstehen
- Stil ist ein niedrigschwelliges Muster, das Basismodelle besser erfassen
Trainingsschleife
import tinker
from tinker import types
training_client = await service_client.create_lora_training_client_async(
base_model="Qwen/Qwen3-8B-Base",
rank=32
)
for epoch in range(3):
for batch in batches:
await training_client.forward_backward_async(batch, loss_fn="cross_entropy")
await training_client.optim_step_async(types.AdamParams(learning_rate=5e-4))
result = await training_client.save_weights_for_sampler_async(name="final")
Phase 6: Validierung
Moderner Szenario-Test
Testen Sie mit Szenarien, die im ursprünglichen Buch nicht existieren könnten:
TEST_PROMPTS = [
"Schreibe über einen Barista, der Lattes zubereitet",
"Beschreibe Liebende, die per Textnachricht kommunizieren",
"Schreibe über jemanden, der wegen des Klimawandels ängstlich ist",
]
Wenn das Modell Stilmerkmale auf moderne Szenarien anwendet, hat es Stil gelernt, nicht Inhalt.
Überprüfung der Originalität
# Trainingsdaten nach Ausgabephrasen durchsuchen
grep "spezifische Phrase aus der Ausgabe" datensatz.jsonl
# Sollte zurückgeben: Keine Treffer
KI-Erkennungs-Test
Testen Sie Ausgaben mit GPTZero, Pangram oder ZeroGPT.
Bekannte Probleme und Lösungen
Leckage von Charakternamen
Symptom: Das Modell verwendet originale Charakternamen in neuen Szenarien. Ursache: Begrenzte Namensvielfalt aus einem Buch. Lösung: Training auf mehreren Büchern oder Hinzufügen synthetischer Beispiele.
Modell wiederholt exakte Phrasen
Symptom: Ausgaben enthalten exakte Sätze aus den Trainingsdaten. Ursache: Zu wenige Prompt-Variationen oder zu viele Epochen. Lösung: Verwenden Sie 15+ Vorlagen, begrenzen Sie auf 3 Epochen.
Fragmentierte Ausgaben
Symptom: Sätze wirken unvollständig. Ursache: Schlechte Segmentierung, die einen Gedanken unterbricht. Lösung: Immer an Absatzgrenzen brechen.
Richtlinien
- Immer ePub gegenüber PDF bevorzugen - OCR-Fehler werden zu erlernten Mustern
- Nie mitten im Satz brechen - Grenzen müssen grammatikalisch vollständig sein
- Vielfältige Prompts verwenden - 15+ Vorlagen, 5+ System-Prompts
- Basismodelle verwenden - Nicht Instruction-Versionen
- Kleinere Blöcke verwenden - 150-400 Wörter für mehr Beispiele
- Testsatz reservieren - Mindestens 50 Beispiele
- Auf modernen Szenarien testen - Beweist Style-Transfer vs. Auswendiglernen
- Originalität überprüfen - Trainingsdaten nach Ausgabephrasen durchsuchen
Erwartete Ergebnisse
| Metrik | Wert |
|---|---|
| Trainingsbeispiele | 500-1000 pro Buch |
| Modell | Qwen/Qwen3-8B-Base |
| LoRA-Rang | 32 |
| Adaptergröße | ~350 MB |
| Trainingszeit | ~15 Min |
| Verlustreduktion | 90%+ |
| Style-Transfer-Erfolg | ~50% perfekt |
Kostenabschätzung
| Komponente | Kosten |
|---|---|
| LLM (Instruktionsgenerierung) | ~0,50 $ |
| Tinker-Training (15 Min) | ~1,50 $ |
| Gesamt | ~2,00 $ |
Integration mit Context-Engineering-Fähigkeiten
Dieses Beispiel wendet mehrere Fähigkeiten aus der Sammlung "Agent Skills for Context Engineering" an.
project-development
Die Pipeline folgt dem stufenweisen, idempotenten Architekturmuster:
- Erwerben: Text aus ePub extrahieren
- Vorbereiten: In Trainingsblöcke segmentieren
- Verarbeiten: Synthetische Instruktionen generieren
- Parsen: Nachrichtenformat erstellen
- Rendern: Tinker-kompatibles JSONL ausgeben
- Trainieren: LoRA-Feintuning
- Validieren: Moderner Szenario-Test
Jede Phase ist fortsetzbar und produziert Zwischenartefakte zum Debuggen.
context-compression
Segmentierung ist eine Form der Kontextkompression für das Training. Die Kern-Erkenntnis aus context-compression gilt: Informationsdichte ist wichtiger als Informationsmenge. Kleinere, kohärente Blöcke (150-400 Wörter) erzeugen einen besseren Style-Transfer als größere, verdünnte Blöcke.
Die zweistufige Strategie spiegelt die Kontextkompressions-Evaluierung wider:
- Stufe 1: Schnelle, deterministische Kompression
- Stufe 2: LLM-unterstützt für Grenzfälle
multi-agent-patterns
Die Pipeline verwendet das Supervisor/Orchestrator-Muster:
- Der Orchestrator koordiniert Phasen und verwaltet den Zustand
- Spezialisierte Agenten (Extraktion, Segmentierung, Instruktion, Ersteller) haben isolierte Kontexte
- Jeder Agent erhält nur die für seine Aufgabe benötigten Informationen
Dies entspricht dem Prinzip, dass Sub-Agenten hauptsächlich dazu dienen, Kontext zu isolieren, anstatt Rollen zu simulieren.
evaluation
Die Validierung folgt dem Endzustands-Evaluierungsmuster:
- Funktionale Tests: Entspricht die Ausgabe den erwarteten Stilmerkmalen?
- Überprüfung der Originalität: Ist der Inhalt wirklich generiert?
- Externe Validierung: KI-Erkennungswerte
Der "Moderne Szenario"-Test ist eine Form der Out-of-Distribution-Evaluierung, die Generalisierung beweist.
context-fundamentals
Prompt-Vielfalt verhindert, dass die Aufmerksamkeit auf einzelne Muster kollabiert. Beim Training mit identischen Prompt-Strukturen speichert das Modell die Instruktions-Antwort-Zuordnung auswendig. Vielfältige Vorlagen zwingen die Aufmerksamkeit auf die Stilmuster selbst.
Referenzen
Interne Referenzen:
- Segmentierungsstrategien - Text-Chunking-Muster
- Tinker Formatspezifikation - Datum-Struktur
- Tinker API-Dokumentation - Vollständige API-Referenz
Verwandte Fähigkeiten aus Agent Skills for Context Engineering:
- project-development - Pipeline-Architekturmuster
- context-compression - Kompressionsstrategien
- multi-agent-patterns - Agentenkoordination
- evaluation - Evaluierungs-Frameworks
- context-fundamentals - Aufmerksamkeit und Informationsdichte
Externe Ressourcen:
- Forschungspapier - Chakrabarty et al. 2025
- Datensatz auf Hugging Face
- Gertrude Stein Fallstudie - Vollständiges funktionierendes Beispiel
Fähigkeitsmetadaten
Erstellt: 2025-12-26 Zuletzt aktualisiert: 2025-12-28 Autor: Muratcan Koylan Version: 2.0.0 Eigenständig: Ja (getrennt von der Haupt-Context-Engineering-Sammlung)