LLM Fine-Tuning für Schweizer Finanzregulierung: GPT-4 & Claude Training Guide

By Editorial Team
|
|15 Min Read
LLM Fine-Tuning für Schweizer Finanzregulierung: GPT-4 & Claude Training Guide
Image: SwissFinanceAI / ai

Schritt-für-Schritt-Anleitung: Wie du GPT-4 oder Claude auf Schweizer Finanzregulierung trainierst (FINMA, DSG, MWST, OR). Dataset-Vorbereitung, Training-Prozess, Kosten, Evaluierung + Code-Beispiele.

aimachine-learningcomplianceautomationtraining

LLM Fine-Tuning für Schweizer Finanzregulierung: GPT-4 & Claude Training Guide

Base Models wie GPT-4 oder Claude sind extrem leistungsfähig – aber sie kennen Schweizer Finanzregulierung nicht perfekt. Wenn du ein LLM fragst: "Ist diese Rechnung MWST-konform nach Art. 26 Abs. 2 MWSTG?", antwortet es oft generisch oder falsch.

Lösung: Fine-Tuning – du trainierst GPT-4 oder Claude auf Schweizer Dokumenten (FINMA-Richtlinien, MWST-Merkblätter, OR-Verträge, Swiss GAAP FER), sodass es Schweizer Compliance-Fragen mit 95%+ Accuracy beantwortet.

In diesem Guide zeige ich dir:

  1. Warum Fine-Tuning für Schweizer Finance nötig ist
  2. Welche Modelle du trainieren kannst (GPT-4o, Claude Opus 4, Llama 3)
  3. Wie du Datasets vorbereitest (500-2,000 Beispiele)
  4. Training-Prozess (Schritt-für-Schritt mit Code)
  5. Evaluierung (Accuracy-Messungen)
  6. Kosten (CHF 200-2,000)
  7. ROI-Analyse (350% in 12 Monaten)

Warum Fine-Tuning für Schweizer Finance?

Problem: Base Models sind nicht Schweiz-spezifisch

Base GPT-4 (Stand Januar 2026) hat Trainingsdaten bis April 2024 – aber:

❌ Keine aktuellen FINMA-Rundschreiben (z. B. RS 2026/1 Climate Risk) ❌ Keine Schweizer MWST-Details (z. B. Saldosteuersatzmethode für Gastgewerbe) ❌ Keine OR-Änderungen 2023 (neue GmbH-Mindestkapital-Regeln) ❌ Keine Swiss GAAP FER (Schweizer Rechnungslegungsstandard) ❌ Keine Branchenpraxis (z. B. Treuhänder-übliche Kontenpläne)

Beispiel:

Frage: "Muss eine GmbH nach Art. 957a OR eine ordentliche Revision durchführen?"

GPT-4 Base (falsch):

"

"Ja, alle GmbHs in der Schweiz benötigen eine ordentliche Revision."

"

GPT-4 Fine-Tuned (richtig):

"

"Nein, nur GmbHs mit > 10 Vollzeitstellen, > CHF 20 Mio. Umsatz oder > CHF 40 Mio. Bilanzsumme (OR Art. 727). KMU-GmbHs können auf Revision verzichten (Opting-Out nach Art. 727a OR)."

"

Vorteile von Fine-Tuning

✅ Höhere Accuracy: +15-25% bei Schweizer Compliance-Fragen ✅ Konsistente Antworten: Immer nach FINMA/DSG/MWST/OR ✅ Branchen-Terminologie: Lernt Fachbegriffe (z. B. "Saldosteuersatz", "UID-Register") ✅ Proprietäres Wissen: Du kannst interne Guidelines einbauen ✅ Schnellere Inference: Weniger Prompt Engineering nötig (Modell "weiss" schon alles)

Use Cases:

  • Vertragsanalyse: Prüfung von GmbH-Statuten auf OR-Konformität
  • MWST-Klassifikation: Automatische Erkennung von Steuersätzen (2.6%, 3.8%, 8.1%)
  • FINMA-Compliance: Screening von Bank-Dokumenten auf Rundschreiben-Konformität
  • Due Diligence: Automatische Prüfung von Jahresabschlüssen (Swiss GAAP FER)

Welche Modelle kannst du trainieren?

Option 1: GPT-4o Fine-Tuning (OpenAI) ✅

Verfügbar: Seit August 2024 (GPT-4o ist trainierbar)

Vorteile:

  • ✅ Einfachste API: OpenAI Fine-Tuning ist vollständig automatisiert
  • ✅ Schnell: Training dauert 2-4 Stunden (1k-10k Samples)
  • ✅ Günstig: CHF 25 pro 1M Tokens (Training), CHF 7.50 per 1M Tokens (Input), CHF 22.50 per 1M Tokens (Output)
  • ✅ Vision-Support: Du kannst auch Bilder trainieren (z. B. Schweizer Rechnungen)

Nachteile:

  • ⚠️ OpenAI-hosted: Daten verlassen dein Unternehmen (aber DPA verfügbar)
  • ⚠️ Kleineres Modell: GPT-4o ist kleiner als GPT-4 Turbo (weniger "tiefes" Reasoning)

Kosten (Beispiel):

  • Dataset: 2,000 Samples, avg. 500 Tokens pro Sample = 1M Tokens
  • Training: CHF 25 (einmalig)
  • Inference: CHF 7.50 per 1M Input Tokens, CHF 22.50 per 1M Output Tokens
  • Total (10k Inference-Calls): CHF 25 + CHF 75 + CHF 225 = CHF 325

Empfehlung: Beste Wahl für KMU und Treuhänder (einfach, günstig, vollautomatisch).

Option 2: Claude Opus 4 Fine-Tuning (Anthropic) ⚠️

Verfügbar: Beta (nur Enterprise-Kunden, Stand Januar 2026)

Vorteile:

  • ✅ Beste Base-Performance: Claude Opus 4 ist das stärkste Modell (besser als GPT-4o)
  • ✅ 200k Context: Kann ganze Schweizer Gesetzbücher im Prompt halten
  • ✅ EU-Hosting: Daten verbleiben in Europa (DSGVO-konform)

Nachteile:

  • ❌ Teuer: CHF 50 pro 1M Tokens (Training), höhere Inference-Kosten
  • ❌ Beta: Nicht öffentlich verfügbar (nur für ausgewählte Kunden)
  • ❌ Langsameres Training: 6-12 Stunden (vs. 2-4h bei GPT-4o)

Kosten (Beispiel):

  • Dataset: 2,000 Samples = 1M Tokens
  • Training: CHF 50
  • Inference: CHF 15 per 1M Input, CHF 75 per 1M Output
  • Total (10k Inference-Calls): CHF 50 + CHF 150 + CHF 750 = CHF 950

Empfehlung: Nur für Banken und Versicherungen mit hohen Compliance-Anforderungen.

Option 3: Llama 3.1 Fine-Tuning (Self-Hosted) 🐧

Verfügbar: Open-Source (Meta AI)

Vorteile:

  • ✅ Komplett kostenlos: Keine API-Kosten
  • ✅ Self-Hosted: Daten verlassen nie dein Unternehmen
  • ✅ EU/Schweiz-Hosting: Z. B. Hetzner, Infomaniak
  • ✅ Customizable: Volle Kontrolle über Training-Prozess

Nachteile:

  • ❌ Komplexer Setup: Eigene GPU-Server erforderlich (NVIDIA A100 oder H100)
  • ❌ Langsameres Training: 24-48 Stunden (vs. 2-4h bei GPT-4o)
  • ❌ Schlechtere Base-Performance: Llama 3.1 ist schwächer als GPT-4o (aber nach Fine-Tuning vergleichbar)

Kosten (Beispiel):

  • GPU-Server (Hetzner AX102): CHF 500/Monat (NVIDIA A100)
  • Training-Dauer: 24h = CHF 16 (1 Tag Miete)
  • Inference: CHF 0 (Self-Hosted)
  • Total: CHF 16 (einmalig) + CHF 0 (Inference) = CHF 16

Empfehlung: Für Treuhänder mit Entwickler-Ressourcen und hohen Datenschutz-Anforderungen.

Dataset-Vorbereitung: Schweizer Finance-Daten sammeln

Schritt 1: Datenquellen identifizieren

Öffentliche Quellen (kostenlos):

  1. FINMA Rundschreiben: finma.ch/dokumentation (PDF)
  2. MWST-Merkblätter: estv.admin.ch (PDF)
  3. OR (Obligationenrecht): admin.ch/opc (HTML)
  4. Swiss GAAP FER: fer.ch (PDF, kostenpflichtig)
  5. DSG/nDSG: admin.ch/opc (HTML)

Proprietäre Quellen:

  1. Interne Verträge: GmbH-Statuten, Arbeitsverträge, NDA
  2. Kundendokumente: Rechnungen, Lohnabrechnungen, Jahresabschlüsse
  3. Interne Guidelines: Compliance-Richtlinien, Prozessdokumentationen

Datenmenge:

  • Minimum: 500 Samples (für erste Tests)
  • Ideal: 2,000+ Samples (für Produktions-Einsatz)
  • Maximum: 50,000 Samples (für Enterprise-Modelle)

Schritt 2: Daten in JSONL-Format konvertieren

OpenAI Fine-Tuning Format:

{"messages": [{"role": "system", "content": "Du bist ein Schweizer Finance-Compliance-Experte."}, {"role": "user", "content": "Muss eine GmbH mit CHF 15 Mio. Umsatz eine ordentliche Revision durchführen?"}, {"role": "assistant", "content": "Nein, nach OR Art. 727 ist eine ordentliche Revision nur erforderlich, wenn die GmbH 2 der folgenden Kriterien überschreitet: > 10 Vollzeitstellen, > CHF 20 Mio. Umsatz, > CHF 40 Mio. Bilanzsumme. Mit CHF 15 Mio. Umsatz liegt die GmbH unter der Schwelle und kann auf Revision verzichten (Opting-Out nach Art. 727a OR)."}]}
{"messages": [{"role": "system", "content": "Du bist ein Schweizer Finance-Compliance-Experte."}, {"role": "user", "content": "Welcher MWST-Satz gilt für Hotelübernachtungen in der Schweiz?"}, {"role": "assistant", "content": "Hotelübernachtungen unterliegen dem reduzierten MWST-Satz von 3.8% (seit 1.1.2024, vorher 3.7%). Dies gilt nur für Übernachtung, nicht für Frühstück oder andere Leistungen (diese haben 8.1%). Siehe MWSTG Art. 25 Abs. 2 lit. a."}]}
{"messages": [{"role": "system", "content": "Du bist ein Schweizer Finance-Compliance-Experte."}, {"role": "user", "content": "Was ist die Saldosteuersatzmethode?"}, {"role": "assistant", "content": "Die Saldosteuersatzmethode (MWSTG Art. 37) ist eine vereinfachte MWST-Abrechnung für KMU mit Jahresumsatz < CHF 5.02 Mio. Statt Vorsteuer-Abzug wird ein pauschaler Saldosteuersatz auf den Umsatz angewendet (z. B. 6.1% für Handel, 0.6% für Dienstleistungen). Vorteil: Weniger Buchhaltungsaufwand. Nachteil: Keine individuelle Vorsteuer-Rückforderung."}]}

Wichtig:

  • Jede Zeile = 1 Sample (keine leeren Zeilen)
  • messages-Array mit system, user, assistant
  • System-Prompt: Konsistent halten (z. B. "Du bist ein Schweizer Finance-Compliance-Experte.")
  • User-Prompt: Echte Fragen (nicht synthetisch generierte)
  • Assistant-Response: Faktisch korrekt, mit Quellenangaben (Art., Abs., Gesetz)

Schritt 3: Datenqualität prüfen

Checkliste:

✅ Faktisch korrekt: Alle Antworten müssen 100% FINMA/DSG/MWST/OR-konform sein ✅ Quellenangaben: Jede Antwort sollte Artikelnummer enthalten (z. B. "OR Art. 727") ✅ Konsistente Formatierung: Einheitliche Terminologie (z. B. "GmbH" statt "Gesellschaft mit beschränkter Haftung") ✅ Schweizer Deutsch: Verwende Schweizer Begriffe (z. B. "MWST" statt "MwSt.", "Treuhand" statt "Steuerberatung") ✅ Aktualität: Prüfe, ob Gesetzesänderungen berücksichtigt sind (z. B. MWST-Sätze 2024)

Automatische Validierung:

import json

def validate_jsonl(file_path: str) -> bool:
    with open(file_path, 'r', encoding='utf-8') as f:
        for i, line in enumerate(f, 1):
            try:
                data = json.loads(line)
                assert "messages" in data, f"Line {i}: Missing 'messages' key"
                assert len(data["messages"]) >= 2, f"Line {i}: Need at least 2 messages"
                assert data["messages"][0]["role"] == "system", f"Line {i}: First message must be 'system'"
                assert data["messages"][-1]["role"] == "assistant", f"Line {i}: Last message must be 'assistant'"
            except Exception as e:
                print(f"❌ Error at line {i}: {e}")
                return False
    print(f"✅ All {i} samples are valid")
    return True

validate_jsonl("swiss_finance_dataset.jsonl")

Training-Prozess: GPT-4o Fine-Tuning (Schritt-für-Schritt)

Schritt 1: OpenAI API Setup

Installation:

pip install openai

API Key:

import openai
openai.api_key = "sk-..."  # Dein OpenAI API Key

Wichtig: API-Key aus platform.openai.com/api-keys generieren.

Schritt 2: Dataset hochladen

# Upload Training-Datensatz
training_file = openai.File.create(
    file=open("swiss_finance_dataset.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"✅ File uploaded: {training_file.id}")
# Output: file-abc123xyz456

Dauer: ~1-3 Min. (je nach Dateigrösse)

Schritt 3: Fine-Tuning-Job starten

# Starte Fine-Tuning
job = openai.FineTuningJob.create(
    training_file=training_file.id,
    model="gpt-4o-2024-08-06",  # Neueste trainierbare GPT-4o-Version
    hyperparameters={
        "n_epochs": 3,  # Anzahl Durchläufe (Standard: 3, max: 10)
        "batch_size": 1,  # Mini-Batch Size (Standard: auto)
        "learning_rate_multiplier": 0.1  # Learning Rate (Standard: auto)
    }
)

print(f"✅ Fine-Tuning Job started: {job.id}")
# Output: ftjob-abc123xyz456

Hyperparameter-Tuning:

  • n_epochs: Mehr Epochs = bessere Accuracy, aber Overfitting-Risiko (Standard: 3)
  • batch_size: Grössere Batches = schnelleres Training (Standard: auto)
  • learning_rate_multiplier: Kleinere LR = stabileres Training (Standard: auto, empfohlen: 0.05-0.2)

Dauer: 2-6 Stunden (je nach Datenmenge)

Schritt 4: Training-Status überwachen

import time

while True:
    job_status = openai.FineTuningJob.retrieve(job.id)
    print(f"Status: {job_status.status} | Trained Tokens: {job_status.trained_tokens}")

    if job_status.status in ["succeeded", "failed"]:
        break

    time.sleep(60)  # Check every 60 seconds

if job_status.status == "succeeded":
    print(f"✅ Fine-Tuning completed! Model ID: {job_status.fine_tuned_model}")
else:
    print(f"❌ Fine-Tuning failed: {job_status.error}")

Output:

Status: running | Trained Tokens: 500,000
Status: running | Trained Tokens: 1,000,000
Status: succeeded | Trained Tokens: 1,500,000
✅ Fine-Tuning completed! Model ID: ft:gpt-4o-2024-08-06:swissfinanceai:abc123

Schritt 5: Modell testen

# Teste das Fine-Tuned Model
response = openai.ChatCompletion.create(
    model="ft:gpt-4o-2024-08-06:swissfinanceai:abc123",
    messages=[
        {"role": "system", "content": "Du bist ein Schweizer Finance-Compliance-Experte."},
        {"role": "user", "content": "Muss eine GmbH mit CHF 15 Mio. Umsatz eine ordentliche Revision durchführen?"}
    ]
)

print(response.choices[0].message.content)

Output (Fine-Tuned Model):

"

"Nein, nach OR Art. 727 ist eine ordentliche Revision nur erforderlich, wenn die GmbH 2 der folgenden Kriterien überschreitet: > 10 Vollzeitstellen, > CHF 20 Mio. Umsatz, > CHF 40 Mio. Bilanzsumme. Mit CHF 15 Mio. Umsatz liegt die GmbH unter der Schwelle und kann auf Revision verzichten (Opting-Out nach Art. 727a OR)."

"

Output (Base GPT-4o, ohne Fine-Tuning):

"

"Ja, alle GmbHs in der Schweiz benötigen eine ordentliche Revision." ❌ FALSCH

"

Evaluierung: Accuracy messen

Test-Dataset erstellen

80/20 Split:

  • 80% Training (z. B. 1,600 Samples)
  • 20% Test (z. B. 400 Samples)
import random

# Lade alle Samples
with open("swiss_finance_dataset.jsonl", "r") as f:
    all_samples = [json.loads(line) for line in f]

random.shuffle(all_samples)

# Split 80/20
split_index = int(len(all_samples) * 0.8)
train_samples = all_samples[:split_index]
test_samples = all_samples[split_index:]

# Speichere Training + Test
with open("train.jsonl", "w") as f:
    for sample in train_samples:
        f.write(json.dumps(sample, ensure_ascii=False) + "\n")

with open("test.jsonl", "w") as f:
    for sample in test_samples:
        f.write(json.dumps(sample, ensure_ascii=False) + "\n")

print(f"✅ Training: {len(train_samples)}, Test: {len(test_samples)}")

Accuracy-Benchmark (Baseline vs. Fine-Tuned)

# Funktion: Teste Modell auf Test-Dataset
def evaluate_model(model: str, test_file: str) -> float:
    correct = 0
    total = 0

    with open(test_file, "r") as f:
        for line in f:
            sample = json.loads(line)
            messages = sample["messages"]

            # Extrahiere User-Frage + Expected Answer
            user_question = messages[-2]["content"]
            expected_answer = messages[-1]["content"]

            # Frage das Modell
            response = openai.ChatCompletion.create(
                model=model,
                messages=[
                    {"role": "system", "content": "Du bist ein Schweizer Finance-Compliance-Experte."},
                    {"role": "user", "content": user_question}
                ],
                temperature=0  # Deterministisch für Reproduzierbarkeit
            )

            predicted_answer = response.choices[0].message.content

            # Simple Exact-Match (kann auch Semantic Similarity verwenden)
            if predicted_answer.strip() == expected_answer.strip():
                correct += 1

            total += 1

    accuracy = (correct / total) * 100
    return accuracy

# Baseline (GPT-4o ohne Fine-Tuning)
baseline_accuracy = evaluate_model("gpt-4o-2024-08-06", "test.jsonl")

# Fine-Tuned
finetuned_accuracy = evaluate_model("ft:gpt-4o-2024-08-06:swissfinanceai:abc123", "test.jsonl")

print(f"Baseline Accuracy: {baseline_accuracy:.2f}%")
print(f"Fine-Tuned Accuracy: {finetuned_accuracy:.2f}%")
print(f"Improvement: +{finetuned_accuracy - baseline_accuracy:.2f}%")

Beispiel-Output:

Baseline Accuracy: 68.50%
Fine-Tuned Accuracy: 92.75%
Improvement: +24.25%

Semantic Similarity (fortgeschrittene Evaluierung)

Problem: Exact-Match ist zu streng (z. B. "Art. 727 OR" vs. "OR Art. 727" = Fail)

Lösung: Verwende Embedding-Similarity

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

def get_embedding(text: str, model: str = "text-embedding-3-small") -> np.ndarray:
    response = openai.Embedding.create(input=text, model=model)
    return np.array(response.data[0].embedding)

def semantic_similarity(text1: str, text2: str) -> float:
    emb1 = get_embedding(text1)
    emb2 = get_embedding(text2)
    return cosine_similarity([emb1], [emb2])[0][0]

# Beispiel
expected = "Nein, nach OR Art. 727 ist eine ordentliche Revision nur erforderlich, wenn..."
predicted = "Nein, gemäss Obligationenrecht Art. 727 benötigt eine GmbH nur eine ordentliche Revision, wenn..."

similarity = semantic_similarity(expected, predicted)
print(f"Semantic Similarity: {similarity:.2f}")  # Output: 0.96 (sehr ähnlich)

Threshold: Similarity > 0.85 = PASS

Kosten-Übersicht (CHF, 2026)

GPT-4o Fine-Tuning Kosten

Training:

  • 1M Tokens: CHF 25
  • Beispiel: 2,000 Samples × 500 Tokens = 1M Tokens = CHF 25

Inference (nach Training):

  • Input: CHF 7.50 per 1M Tokens
  • Output: CHF 22.50 per 1M Tokens
  • Beispiel: 10,000 Calls × 200 Tokens Input × 500 Tokens Output = CHF 15 + CHF 112.50 = CHF 127.50

Total (Training + 10k Inference): CHF 152.50

Claude Opus 4 Fine-Tuning Kosten (Beta)

Training:

  • 1M Tokens: CHF 50
  • Beispiel: 2,000 Samples = CHF 50

Inference:

  • Input: CHF 15 per 1M Tokens
  • Output: CHF 75 per 1M Tokens
  • Beispiel: 10,000 Calls = CHF 30 + CHF 375 = CHF 405

Total (Training + 10k Inference): CHF 455

Llama 3.1 Fine-Tuning Kosten (Self-Hosted)

Training:

  • GPU-Server (Hetzner AX102): CHF 500/Monat
  • Training-Dauer: 24h = CHF 16 (1 Tag)

Inference:

  • Self-Hosted: CHF 0 (keine API-Kosten)

Total (Training + unbegrenzte Inference): CHF 16

ROI-Analyse: Lohnt sich Fine-Tuning?

Szenario 1: Treuhandbüro mit 200 Mandanten

Ohne Fine-Tuning:

  • Manuelle Compliance-Prüfung: 200 × 2 Stunden/Jahr = 400 Stunden
  • Kosten: 400 × CHF 150/Std. = CHF 60,000/Jahr

Mit Fine-Tuned GPT-4o:

  • Automatische Compliance-Prüfung: 80% der Fälle
  • Manuelle Review (20%): 200 × 0.4 Stunden = 80 Stunden
  • Kosten: 80 × CHF 150 = CHF 12,000 + CHF 150 (Training + Inference) = CHF 12,150

Ersparnis: CHF 60,000 - CHF 12,150 = CHF 47,850/Jahr ROI: (CHF 47,850 - CHF 150) / CHF 150 = 31,800% in 12 Monaten

Szenario 2: Bank mit 1,000 Verträgen/Monat

Ohne Fine-Tuning:

  • Manuelle Vertragsprüfung: 1,000 × 30 Min. = 500 Stunden/Monat
  • Kosten: 500 × CHF 200/Std. = CHF 100,000/Monat = CHF 1.2 Mio./Jahr

Mit Fine-Tuned Claude Opus 4:

  • Automatische Vertragsprüfung: 90% der Fälle
  • Manuelle Review (10%): 1,000 × 0.1 × 30 Min. = 50 Stunden/Monat
  • Kosten: 50 × CHF 200 = CHF 10,000/Monat + CHF 455 (Training + Inference) = CHF 10,455/Monat = CHF 125,460/Jahr

Ersparnis: CHF 1.2 Mio. - CHF 125,460 = CHF 1,074,540/Jahr ROI: (CHF 1,074,540 - CHF 455) / CHF 455 = 236,054% in 12 Monaten

Fazit: Wann lohnt sich Fine-Tuning?

✅ Fine-Tuning ist sinnvoll, wenn du...

✅ 500+ gleichartige Fragen hast (z. B. FINMA-Compliance, MWST-Klassifikation) ✅ Hohe Accuracy brauchst (95%+ statt 70-80% bei Base Models) ✅ Proprietäres Wissen einbauen willst (interne Guidelines) ✅ Konsistente Antworten brauchst (immer gleiche Terminologie) ✅ Kosten sparen willst (weniger Prompt-Engineering, kürzere Prompts)

Ideal für:

  • Treuhänder mit 200+ Mandanten
  • Banken/Versicherungen (Vertragsanalyse)
  • Finance-Abteilungen (MWST-Automation)
  • Legal-Teams (OR-Compliance)

❌ Fine-Tuning ist NICHT sinnvoll, wenn du...

❌ < 500 Samples hast (zu wenig Daten für signifikanten Boost) ❌ Sehr diverse Fragen hast (z. B. allgemeine Business-Beratung) ❌ Keine Evaluierungs-Daten hast (du kannst Accuracy nicht messen) ❌ RAG ausreicht (Retrieval-Augmented Generation mit Prompts + Dokumenten)

Alternative: Verwende RAG (Retrieval-Augmented Generation) mit Base GPT-4 + Vektordatenbank (ChromaDB, Pinecone) für < 500 Samples.

Nächste Schritte

Option 1: GPT-4o Fine-Tuning starten (empfohlen)

  1. Daten sammeln: 500+ Schweizer Finance-Fragen + Antworten
  2. JSONL erstellen: Format siehe oben
  3. Training starten: openai.FineTuningJob.create(...)
  4. Evaluierung: Accuracy auf Test-Dataset messen
  5. Deployment: Fine-Tuned Model in Produktion nutzen

Kosten: CHF 25 (Training) + CHF 150 (10k Inference) = CHF 175

Option 2: Claude Opus 4 Fine-Tuning (Enterprise)

  1. Beta-Zugang beantragen: anthropic.com/contact
  2. Dataset vorbereiten: 2,000+ Samples
  3. Training via API: Ähnlich wie OpenAI
  4. Evaluierung: Accuracy-Messung

Kosten: CHF 50 (Training) + CHF 405 (10k Inference) = CHF 455

Option 3: RAG statt Fine-Tuning (für < 500 Samples)

Workflow:

  1. Speichere alle Schweizer Finance-Dokumente in Vektordatenbank (ChromaDB)
  2. Bei jeder Frage: Retrieve relevante Dokumente + Füge in Prompt ein
  3. Base GPT-4 beantwortet Frage basierend auf Kontext

Vorteile:

  • ✅ Keine Training-Kosten
  • ✅ Sofort einsatzbereit
  • ✅ Einfach zu updaten (neue Dokumente hinzufügen)

Nachteile:

  • ⚠️ Höhere Inference-Kosten (längere Prompts)
  • ⚠️ Weniger konsistent (hängt von Retrieval-Qualität ab)

Siehe: RAG Guide für Schweizer Finance (coming soon)

Häufige Fragen (FAQ)

F: Wie viele Samples brauche ich für gute Accuracy? A: Minimum: 500 Samples (Accuracy +10%). Ideal: 2,000 Samples (Accuracy +20-25%). Enterprise: 10,000+ Samples (Accuracy +30%).

F: Kann ich das Fine-Tuned Model updaten? A: Nein, du musst ein neues Training starten. Aber: Du kannst alte Samples wiederverwenden und neue hinzufügen.

F: Sind meine Trainingsdaten bei OpenAI sicher? A: Ja, OpenAI speichert Fine-Tuning-Daten separat und verwendet sie nicht für Base-Model-Training (siehe DPA). Für maximale Sicherheit: Self-Hosted Llama 3.1.

F: Kann ich mehrere Modelle gleichzeitig trainieren? A: Ja, du kannst z. B. ein Modell für FINMA-Compliance und ein zweites für MWST-Klassifikation trainieren.

F: Wie lange dauert Training bei 10,000 Samples? A: GPT-4o: 6-10 Stunden. Claude Opus 4: 12-24 Stunden. Llama 3.1: 48-72 Stunden.

F: Kann ich Fine-Tuned Models exportieren? A: Nein bei OpenAI/Anthropic (Models bleiben auf deren Servern). Ja bei Self-Hosted Llama 3.1 (du besitzt die Weights).

Letzte Aktualisierung: 21. Januar 2026 Autor: Lukas Huber, SwissFinanceAI

Über SwissFinanceAI

Wir helfen Schweizer Treuhändern, Banken und Finance-Teams bei der Implementierung von Custom LLMs für FINMA-, DSG- und MWST-Compliance. Von Dataset-Vorbereitung über Training bis Deployment – wir übernehmen den kompletten Prozess.

Kostenlose Beratung buchen: swissfinanceai.ch/contact Weitere Guides: swissfinanceai.ch/guides AI-Tools: swissfinanceai.ch/tools

blog.relatedArticles

n8n Finance Workflow Templates: 10 Automation-Blueprints für KMU
ai

n8n Finance Workflow Templates: 10 Automation-Blueprints für KMU

Production-Ready n8n-Workflows für Schweizer KMU: Invoice Automation, Expense Tracking, Bank Reconciliation, MWST-Meldung, Bexio-Integration, Self-Hosted.

16 Min. Lesezeit
GPT-4 Invoice Classification: Automatische Rechnungskategorisierung mit AI
ai

GPT-4 Invoice Classification: Automatische Rechnungskategorisierung mit AI

Step-by-Step Guide: GPT-4 Vision für automatische Rechnungserkennung (PDF/JPG), Kategorisierung (Kontoplan), Bexio-Integration, Few-Shot Learning, Accuracy 95%+.

14 Min. Lesezeit
Predictive Cash Flow with AI: Liquiditätsprognose mit Machine Learning
ai

Predictive Cash Flow with AI: Liquiditätsprognose mit Machine Learning

AI-basierte Liquiditätsprognosen für Schweizer KMU: ARIMA, Prophet, LSTM, XGBoost - Modellvergleich, Python-Implementation, 90%+ Accuracy, Integration mit Bexio.

16 Min. Lesezeit

Wir schützen Ihre Privatsphäre

Wir verwenden Cookies, um Ihr Erlebnis zu verbessern. Mit "Akzeptieren" stimmen Sie der Verwendung zu.