KI & Engineering Programme›🔧 Fine-Tuning und Evaluierung›Lektionen›Training Data Preparation

🔧

Fine-Tuning und Evaluierung • Anfänger⏱️ 30 Min. Lesezeit

Training Data Preparation

So viel Geschäftsmaterial - wie wird es in Trainingsdaten umgewandelt?

Vor dem Training eines Modells stellen wir uns oft folgende Frage:

Ich habe viele Rohmaterialien, Produktbeschreibungen, Betriebshandbücher und Geschäftsspezifikationen, jeweils in unterschiedlichen Formatierungen, und der Inhalt ist ziemlich verstreut.

Wie kann ich diese Daten nutzen?

Und wenn ich direkt Daten aus einem bestimmten Bereich oder Szenario verwende, hat das trainierte Modell dann noch die Fähigkeit, allgemeines Wissen zu beantworten?

Der Schlüssel liegt also darin, wie wir alle Materialien in trainierbare Daten für das Modell umwandeln.

Gleichzeitig sind Datenbereinigung, Deduplizierung und Anonymisierung unverzichtbar. Wir haben möglicherweise Daten destilliert, aber müssen sie an unsere gewünschten Ergebnisse anpassen.

Ähnlich wie beim Training eines Modells: Wenn die Selbsterkennungsdaten nicht richtig trainiert sind, könnte das Modell antworten, es sei ein ChatGPT-Modell, ein Claude-Modell usw.

Daten sind die Grundlage für alles. In diesem Kapitel beginnen wir mit den Datenquellen und untersuchen, wie diese verstreuten Materialien durch Synthese, Bereinigung, Deduplizierung und Anonymisierung schließlich in trainierbare Daten für das Modell umgewandelt werden.

Geschäftliches lernen und Allgemeinwissen behalten

Das Sammeln und Annotieren von Trainingsdaten von Grund auf erfordert erheblichen Zeit- und Kostenaufwand. Für gängige Aufgaben wie Textklassifikation, Frage-Antwort und Textgenerierung können geeignete öffentliche Datensätze in das Training einbezogen werden.

Gängige öffentliche Datensätze umfassen:

Textklassifikation und -inferenz: GLUE, SuperGLUE, CLUE usw.;
Leseverständnis und Frage-Antwort: SQuAD, CMRC usw.;
Textzusammenfassung: CNN/DailyMail usw.;
Dialoge und Instruktionsoptimierung: Alpaca, ShareGPT, OpenOrca usw.;
Multimodale Aufgaben: COCO usw. (Bild-Text-Datensätze).

Neben dem Bezug von Daten über die offizielle Datensatz-Website können Open-Source-Datensätze auch über den ModelScope Dataset Hub gesucht und verwendet werden. Der Dataset Hub bietet Funktionen wie Datensatzsuche, Online-Vorschau und Download. Einige Datensätze können auch direkt über die ModelScope SDK geladen werden, was die nachfolgende Verarbeitung und das Training erleichtert. Die spezifischen Methoden zum Download von Datensätzen finden Sie im Abschnitt „Daten – die Grundlage für Feinabstimmung von Open-Source-Modellen".

Bei der Auswahl von Open-Source-Datensätzen muss nicht nur geprüft werden, ob die Dateninhalte mit der Trainingsaufgabe übereinstimmen, sondern auch die Anzahl der Samples, das Feldformat, die Labeltypen und die Datenqualität des Datensatzes, um festzustellen, ob sie den Anforderungen entsprechen. Die von ModelScope bereitgestellte Datenvorschaufunktion hilft, die Felder und Sample-Inhalte eines Datensatzes schnell zu überprüfen. Ein Beispiel ist unten zu sehen:

Lektion 1 von 40% abgeschlossen

←Zurück zum Programm

Diskussion

Anmelden an der Diskussion teilnehmen

from modelscope import AutoModelForCausalLM, AutoTokenizer
import torch
model_id = "Qwen/Qwen3-4B"
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

document = """Rückerstattungsanträge müssen einer manuellen Prüfung unterzogen werden; eine Rückerstattung erfolgt erst nach Bestätigung."""
question = "Muss die Rückerstattung geprüft werden?"
answer = "Die Rückerstattung erfolgt automatisch nach Einreichung, eine manuelle Prüfung ist nicht erforderlich."
prompt = f"""
Bitte beurteilen Sie anhand der Referenzmaterialien, ob die folgenden Frage-Antwort-Daten korrekt sind.

Referenzmaterialien:
{document}

Frage:
{question}

Antwort:
{answer}

Bitte geben Sie strikt im folgenden JSON-Format aus und geben Sie keine anderen Inhalte aus:
{{"result": "Bestanden/Nicht bestanden","reason": "Begründung"}}
"""

messages = [{"role": "user", "content": prompt}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=False)
inputs = tokenizer(text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
result = tokenizer.decode(
    outputs[0][inputs.input_ids.shape[1]:],
    skip_special_tokens=True
)

print("Ergebnis:", result)

from modelscope import AutoModelForCausalLM, AutoTokenizer
import torch
model_id = "Qwen/Qwen3-4B"
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

document = "Das Produkt unterstützt maximal 100 GB Speicherplatz."
question = "Wie viel Speicherplatz unterstützt das Produkt maximal?"
answer = "Das Produkt unterstützt maximal 500 GB Speicherplatz."

prompt = f"""
Bitte beurteilen Sie anhand der Referenzmaterialien, ob die folgende Antwort erfundene Informationen enthält.

Referenzmaterialien:
{document}

Frage:
{question}

Antwort:
{answer}

Bitte geben Sie strikt im folgenden JSON-Format aus und geben Sie keine anderen Inhalte aus:
{{"result": "Bestanden/Nicht bestanden","reason": "Begründung"}}

Bewertungsanforderungen:
1. Wenn die Informationen in der Antwort durch die Referenzmaterialien gestützt werden, geben Sie für result "Bestanden" aus;
2. Wenn die Antwort Informationen enthält, die in den Referenzmaterialien nicht vorhanden sind, geben Sie für result "Nicht bestanden" aus;
3. Beurteilen Sie ausschließlich anhand der Referenzmaterialien und ergänzen Sie kein externes Wissen.
"""

messages = [{"role": "user", "content": prompt}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=False)
inputs = tokenizer(text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
result = tokenizer.decode(
    outputs[0][inputs.input_ids.shape[1]:],
    skip_special_tokens=True
)

print("Ergebnis:", result)

faq_data = [
    {
        "question": "  Wie ändere ich mein Anmeldepasswort?  ",
        "answer": "<p>Gehen Sie in das persönliche Konto und klicken Sie auf „Passwort ändern\".</p>"
    },
    {
        "question": "",
        "answer": "Bitte kontaktieren Sie den Administrator."
    },
    {
        "question": "Was tun, wenn ich mein Passwort vergessen habe?",
        "answer": "Klicken Sie auf „Passwort vergessen"\n\nund folgen Sie den Anweisungen."
    },
    {
        "question": "Wie lautet die Kundenservice-Nummer?",
        "answer": "Die Kundenservice-Nummer lautet 400-123-4567\xa0"
    }
]

import re

def clean_text(text):
    if not text:
        return ""

    # HTML-Tags entfernen
    text = re.sub(r"<[^>]+>", "", text)

    # Spezielle Leerzeichen in normale Leerzeichen umwandeln
    text = text.replace("\xa0", " ")

    # Aufeinanderfolgende Leerzeichen zusammenfassen
    text = re.sub(r"\s+", " ", text)

    # Leerzeichen am Anfang und Ende entfernen
    text = text.strip()

    return text

clean_data = []

for item in faq_data:
    question = clean_text(item["question"])
    answer = clean_text(item["answer"])

    # Daten mit leerer Frage oder Antwort löschen
    if not question or not answer:
        continue

    clean_data.append({
        "question": question,
        "answer": answer
    })

print("Bereinigungsergebnis:", clean_data)

faq_data = [
    {
        "question": "Wie ändere ich mein Anmeldepasswort?",
        "answer": "Gehen Sie in das persönliche Konto und klicken Sie auf „Passwort ändern"."
    },
    {
        "question": "Was tun, wenn ich mein Passwort vergessen habe?",
        "answer": "Klicken Sie auf „Passwort vergessen" und folgen Sie den Anweisungen."
    },
    {
        "question": "Wie ändere ich mein Anmeldepasswort?",
        "answer": "Gehen Sie in das persönliche Konto und klicken Sie auf „Passwort ändern"."
    }
]

seen = set()
result = []

for item in faq_data:
    # Frage und Antwort zu einem Text kombinieren
    text = item["question"] + item["answer"]

    if text not in seen:
        seen.add(text)
        result.append(item)

print("Deduplizierungsergebnis:", result)

import hashlib

seen = set()
result = []

for item in faq_data:
    # Frage und Antwort zu einem Text kombinieren
    text = item["question"] + item["answer"]

    # Hashwert berechnen
    text_hash = hashlib.sha256(
        text.encode("utf-8")
    ).hexdigest()

    if text_hash not in seen:
        seen.add(text_hash)
        result.append(item)

print("Deduplizierungsergebnis:", result)

faq_data = [
    {
        "question": "Wie ändere ich mein Anmeldepasswort?",
        "answer": "Gehen Sie in das persönliche Konto und klicken Sie auf „Passwort ändern"."
    },
    {
        "question": "Wie kann ich das Anmeldepasswort ändern?",
        "answer": "Gehen Sie in das persönliche Konto und klicken Sie auf „Passwort ändern"."
    },
    {
        "question": "Wie beantrage ich eine Rechnung?",
        "answer": "Gehen Sie zur Bestellseite, wählen Sie die Rechnungsanfrage aus und übermitteln Sie die Informationen."
    }
]

J(A,B)=\frac{|A\cap B|}{|A\cup B|}

A\cap B

A\cup B

!pip install datasketch

from datasketch import MinHash

def get_minhash(item):
    text = item["question"] + item["answer"]

    m = MinHash(num_perm=128)
    for char in set(text):
        m.update(char.encode("utf-8")

    return m

result = []
hashes = []

for item in faq_data:
    current_hash = get_minhash(item)

    is_duplicate = any(
        current_hash.jaccard(h) > 0.8
        for h in hashes
    )

    if not is_duplicate:
        result.append(item)
        hashes.append(current_hash)

print("Deduplizierungsergebnis:", result)

!pip install simhash

from simhash import Simhash

def get_simhash(item):
    text = item["question"] + item["answer"]
    return Simhash(text)

result = []
kept_hashes = []

for item in faq_data:
    current_hash = get_simhash(item)

    # Prüfen, ob bereits ein ähnliches FAQ vorhanden ist
    is_duplicate = any(
        current_hash.distance(h) <= 20
        for h in kept_hashes
    )

    # Wenn keine ähnlichen Daten vorhanden sind, beibehalten
    if not is_duplicate:
        result.append(item)
        kept_hashes.append(current_hash)

print("Deduplizierungsergebnis:", result)

\operatorname{sim}(A,B) = \frac{A\cdot B}{\|A\|\|B\|}

!modelscope download --model BAAI/bge-small-zh-v1.5 --local_dir /mnt/workspace/bge-small-zh-v1.5

!pip3 install -U sentence-transformers

from sentence_transformers import SentenceTransformer

texts = [
    item["question"] + item["answer"]
    for item in faq_data
]

model = SentenceTransformer(
    "/mnt/workspace/bge-small-zh-v1.5"
)

embeddings = model.encode(
    texts,
    normalize_embeddings=True
)

result = []
kept_embeddings = []

for item, embedding in zip(faq_data, embeddings):
    is_duplicate = any(
        embedding @ kept_embedding > 0.9
        for kept_embedding in kept_embeddings
    )

    if not is_duplicate:
        result.append(item)
        kept_embeddings.append(embedding)

print("Deduplizierungsergebnis:", result)

import re

text = """
Kunde Zhang San, Telefonnummer 13812345678,
Ausweisnummer 320102199001011234,
E-Mail zhangsan@example.com.
"""

patterns = {
    "Telefonnummer": r"(?<!\d)(1[3-9]\d{9})(?!\d)",
    "Ausweisnummer": r"(?<!\d)(\d{17}[\dXx])(?!\d)",
    "E-Mail": r"([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})"
}

entities = []

for label, pattern in patterns.items():
    for match in re.finditer(pattern, text):
        entities.append({
            "label": label,
            "text": match.group(),
            "start": match.start(),
            "end": match.end()
        })

for entity in entities:
    print(entity)

from transformers import AutoModelForTokenClassification, AutoTokenizer
import torch

model_name = "/mnt/workspace/AIguard-pii-detection-fast"

tokenizer = AutoTokenizer.from_pretrained(
    model_name,
    trust_remote_code=True
)

model = AutoModelForTokenClassification.from_pretrained(
    model_name,
    trust_remote_code=True,
    device_map="auto"
)

# Label-Zuordnung abrufen
id2label = model.config.id2label

def predict_pii(text, max_length=512):
    inputs = tokenizer(
        text,
        return_tensors="pt",
        truncation=True,
        max_length=max_length,
        return_offsets_mapping=True
    )
    offset_mapping = inputs.pop("offset_mapping")[0].tolist()
    
    inputs = {k: v.to(model.device) for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model(**inputs)

    predictions = torch.argmax(outputs.logits, dim=-1)[0].tolist()
    
    # BIOE-Dekodierung
    entities = []
    current_entity = None

    for idx, (pred_id, (start, end) in enumerate(zip(predictions, offset_mapping):
        label = id2label[pred_id]

        if label.startswith("B-"):
            if current_entity:
                entities.append(current_entity)
            current_entity = {
                "start": start,
                "end": end,
                "label": label[2:],
                "text": text[start:end]
            }
        elif label.startswith("I-") or label.startswith("E-"):
            if current_entity and current_entity["label"] == label[2:]:
                current_entity["end"] = end
                current_entity["text"] = text[current_entity["start"]:end]
                if label.startswith("E-"):
                    entities.append(current_entity)
                    current_entity = None
        else:
            if current_entity:
                entities.append(current_entity)
                current_entity = None

    if current_entity:
        entities.append(current_entity)

    return {"text": text, "entities": entities}
    
# Test
text = "Hallo, mein Name ist Zhang San, Ausweisnummer 110101199001011234, Bankkontonummer 6222021234567890123, E-Mail zhangsan@example.com, Adresse Zhongshan North Road 100, Gulou, Nanjing, Jiangsu."

result = predict_pii(text)
for entity in result["entities"]:
    print(entity)

text = "Kunde Zhang San stellt Antrag, Li Si ist für die Prüfung zuständig."

# Im vorherigen Schritt erkannte sensible Informationen
entities = [
    {"label": "Name", "text": "Zhang San"},
    {"label": "Name", "text": "Li Si"}
]

def replace_name(name):
    return name[0] + "Mou"

# Anhand der Erkennungsergebnisse ersetzen
for entity in entities:
    if entity["label"] == "Name":
        entity["result"] = replace_name(entity["text"])

        text = text.replace(
            entity["text"],
            entity["result"]
        )

print("Nach Anonymisierung:", text)

import random

text = "Kunde Zhang San stellt Antrag, der Kundenservice kontaktiert Zhang San."
entities = [
    {"label": "Name", "text": "Zhang San"},
    {"label": "Name", "text": "Zhang San"}
]
fake_names = ["Li Ming", "Wang Qiang", "Zhao Wei"]
name_map = {}

def replace_name_random(name):
    if name not in name_map:
        name_map[name] = random.choice(fake_names)
    return name_map[name]

for entity in entities:
    if entity["label"] == "Name":

        entity["result"] = replace_name_random(
            entity["text"]
        )

        text = text.replace(
            entity["text"],
            entity["result"]
        )

print("Nach Anonymisierung:", text)
print("Zuordnungstabelle:", name_map)

text = "Kunde Telefonnummer 13812345678, Ausweisnummer 110101199001011234, Bankkontonummer 6222021234567890123, E-Mail zhangsan@example.com."

# Im vorherigen Schritt erkannte sensible Informationen
entities = [
    {"label": "Telefonnummer", "text": "13812345678"},
    {"label": "Ausweisnummer", "text": "110101199001011234"},
    {"label": "Bankkontonummer", "text": "6222021234567890123"},
    {"label": "E-Mail", "text": "zhangsan@example.com"}
]

def mask_value(entity):
    text = entity["text"]

    if entity["label"] == "Telefonnummer":
        return (
            text[:3]
            + "****"
            + text[-4:]
        )

    if entity["label"] == "Ausweisnummer":
        return (
            text[:6]
            + "********"
            + text[-4:]
        )

    if entity["label"] == "Bankkontonummer":
        return (
            text[:4]
            + "***********"
            + text[-4:]
        )

    if entity["label"] == "E-Mail":
        username, domain = text.split("@")
        return "***@" + domain

    return text

# Anhand der Erkennungsergebnisse maskieren
for entity in entities:
    result = mask_value(entity)

    text = text.replace(
        entity["text"],
        result
    )

print("Nach Anonymisierung:", text)

text = "Kundenadresse: Zhongshan North Road 100, Gulou, Nanjing, Jiangsu, Alter: 36 Jahre, Registrierungsdatum: 15. August 2025."

# Im vorherigen Schritt erkannte sensible Informationen
entities = [
    {
        "label": "Adresse",
        "text": "Zhongshan North Road 100, Gulou, Nanjing, Jiangsu"
    },
    {
        "label": "Alter",
        "text": "36 Jahre"
    },
    {
        "label": "Zeit",
        "text": "15. August 2025"
    }
]

def generalize(entity):

    text = entity["text"]

    # Adresse: Auf Stadtebene reduzieren
    if entity["label"] == "Adresse":
        if "Nanjing" in text:
            return "Nanjing"

    # Alter: In Altersbereich umwandeln
    if entity["label"] == "Alter":
        age = int(text.replace(" Jahre", ""))

        if age < 18:
            return "Unter 18 Jahre"
        elif age < 40:
            return "18-40 Jahre"
        elif age < 60:
            return "40-60 Jahre"
        else:
            return "Über 60 Jahre"

    # Zeit: Auf Monat reduzieren
    if entity["label"] == "Zeit":
        return text[:7]

    return text

# Anhand der Erkennungsergebnisse verallgemeinern
for entity in entities:
    result = generalize(entity)

    text = text.replace(
        entity["text"],
        result
    )

print("Nach Anonymisierung:", text)

data = {"Name": "Zhang San", "Telefonnummer": "13812345678", "Frage": "Wie kann ich das Geschäft abwickeln?", "Antwort": "Sie können den Antrag online stellen."}

remove_fields = ["Name", "Telefonnummer"]

for field in remove_fields:
    data.pop(field, None)

print("Nach Anonymisierung:", data)

{
  "instruction": "Übersetzen Sie den folgenden chinesischen Text ins Englische",
  "input": "Das Wetter ist heute sehr schön.",
  "output": "The weather is very nice today."
}

{
  "instruction": "Erklären Sie, was maschinelles Lernen ist",
  "input": "",
  "output": "Maschinelles Lernen ist eine Methode, mit der Computer aus Daten Muster und Gesetzmäßigkeiten erlernen."
}

{
  "messages": [
    {
      "role": "system",
      "content": "Sie sind ein professioneller Kundenservice-Assistent."
    },
    {
      "role": "user",
      "content": "Wann kommt meine Bestellung an?"
    },
    {
      "role": "assistant",
      "content": "Bitte geben Sie Ihre Bestellnummer an, ich werde die Nachverfolgung für Sie durchführen."
    }
  ]
}

{
  "messages": [
    {
      "role": "system",
      "content": "Sie sind ein professioneller Kundenservice-Assistent."
    },
    {
      "role": "user",
      "content": "Wie ändere ich mein Anmeldepasswort?"
    },
    {
      "role": "assistant",
      "content": "Gehen Sie in die Kontoeinstellungen und wählen Sie „Passwort ändern"."
    },
    {
      "role": "user",
      "content": "Was tun, wenn ich das alte Passwort vergessen habe?"
    },
    {
      "role": "assistant",
      "content": "Auf der Anmeldeseite können Sie „Passwort vergessen" wählen und nach Verifizierung über Telefonnummer oder E-Mail ein neues Passwort festlegen."
    }
  ]
}

{
  "conversations": [
    {
      "from": "human",
      "value": "Übersetzen Sie den folgenden chinesischen Text ins Englische: Das Wetter ist heute sehr schön."
    },
    {
      "from": "gpt",
      "value": "The weather is very nice today."
    }
  ]
}

{
  "conversations": [
    {
      "from": "human",
      "value": "Schreiben Sie mir eine Abwesenheits-E-Mail."
    },
    {
      "from": "gpt",
      "value": "Bitte teilen Sie mir den Zeitraum und den Grund der Abwesenheit mit."
    },
    {
      "from": "human",
      "value": "Ich bin erkältet und brauche zwei Tage Krankheitsurlaub."
    },
    {
      "from": "gpt",
      "value": "Gut, hier ist ein Entwurf für die Abwesenheits-E-Mail..."
    }
  ]
}

Methode	Bewertungsgrundlage	Geeignetes Szenario
Textdirektübereinstimmung	Vollkommen gleicher Text	Wenige identische Daten
Hash	Gleicher Hashwert des Texts	Viele identische Daten
MinHash	Überlappungsgrad von Wörtern oder Zeichen im Text	Wörtlich ähnliche Daten
SimHash	Hamming-Distanz zwischen Textfingerabdrücken	Inhaltlich ähnliche Daten mit geringen Änderungen
Vektorähnlichkeit	Semantische Ähnlichkeit des Texts	Unterschiedliche Formulierung, aber ähnliche Bedeutung

Datenformat	Hauptmerkmale	Geeignete Szenarien
Alpaca	Organisation der Daten über instruction, input und output	Einstufige Instruktionen, Frage-Antwort, Klassifikation
Messages	Dialogspeicherung über messages, Unterscheidung der Rollen über role	Ein- oder mehrstufige Dialoge
ShareGPT	Dialogspeicherung über conversations, Unterscheidung der Rollen über from	Ein- oder mehrstufige Dialoge

KI-Grundlagen

KI-Meisterschaft

KI-Praxis

Claude Akademie

Labor

Karriereentwicklung

Training Data Preparation

So viel Geschäftsmaterial - wie wird es in Trainingsdaten umgewandelt?

Geschäftliches lernen und Allgemeinwissen behalten

Diskussion

Wie werden eigene Geschäftsmaterialien verwendet?

Nur Dokumente ohne Q&A – das Modell bei der Datensynthese unterstützen

Generierte Daten nicht direkt zum Training verwenden

Stimmen die Antworten mit dem Original überein?

Was nicht im Original steht, soll das Modell nicht erfinden

Andere Formulierung, aber gleiche Frage

Daten aus verschiedenen Quellen zusammenführen

Benötigte Inhalte sammeln und Felder vereinheitlichen

Daten müssen zuerst bereinigt werden

Müssen doppelte Daten alle aufbewahrt werden?

Deduplizierung identischer Daten

Deduplizierung ähnlicher Daten

Echte Informationen: Vor dem Training anonymisieren

Methoden zur Erkennung sensibler Informationen

Anonymisierungsmethoden

Letzter Schritt: Formatierung für das Training

Alpaca-Format

Messages-Format

ShareGPT-Format

Wie wählt man das Datenformat?