Feinabstimmung kognitiver Verzerrungen in Python

In diesem Tutorial bauen wir ein leistungsfähiges Werkzeug, das Text automatisch mit gängigen kognitiven Verzerrungen kennzeichnen kann. Wir nehmen ein vortrainiertes „Mini-Transformer“-Modell, DistilBERT, und feinjustieren es auf einem eigenen Datensatz. DistilBERT ist eine ausgezeichnete Wahl, da es eine kleinere, schnellere Version des beliebten BERT-Modells ist und sich damit ideal für Anwendungen eignet, bei denen Effizienz wichtig ist.

Am Ende dieses Leitfadens verfügen Sie über ein funktionierendes Modell zur Mehrfachkennzeichnung von Texten und ein tieferes Verständnis dafür, wie sich Transformer-Modelle auf spezialisierte NLP-Aufgaben anwenden lassen.

Voraussetzungen:

• Grundlegendes Verständnis von Python und Konzepten des maschinellen Lernens.
• Vertrautheit mit der Kommandozeile.
• Python 3.7+ ist installiert.
• Ein Hugging-Face-Konto (für eine mögliche Modellfreigabe).

Das Problem verstehen

Die zentrale Herausforderung besteht darin, einem Modell des maschinellen Lernens beizubringen, subtile Sprachmuster zu erkennen, die bestimmten kognitiven Verzerrungen entsprechen. Die Aussage „Ich vermassle immer alles“ ist beispielsweise ein klassisches Beispiel für „Übergeneralisierung“. Unser Modell muss lernen, solche Formulierungen mit der richtigen Bezeichnung zu verknüpfen.

Es handelt sich um ein Problem der Mehrfachkennzeichnung, weil ein einzelner Text mehr als eine Art kognitiver Verzerrung aufweisen kann. Der Satz „Ich bin ein völliger Versager, und ich weiß, dass alle das denken“ könnte beispielsweise sowohl mit „Etikettierung“ als auch mit „Gedankenlesen“ gekennzeichnet werden.

Bestehende Lösungen haben gezeigt, dass transformerbasierte Modelle bei dieser Aufgabe eine Leistung erreichen können, die mit der menschlicher klinischer Bewerterinnen und Bewerter vergleichbar ist. Darauf bauen wir mit einer praktischen, schrittweisen Umsetzung auf.

Voraussetzungen

Bevor wir mit dem Programmieren beginnen, richten wir unsere Umgebung ein. Es wird dringend empfohlen, eine virtuelle Umgebung zur Verwaltung Ihrer Abhängigkeiten zu verwenden.

Installieren Sie zunächst die erforderlichen Bibliotheken:

pip install transformers datasets pandas scikit-learn torch

• transformers: Stellt das DistilBERT-Modell und die Werkzeuge für die Feinjustierung bereit.
• datasets: Eine Hugging-Face-Bibliothek zum einfachen Laden und Verarbeiten von Daten.
• pandas: Wird für die Datenbearbeitung verwendet.
• scikit-learn: Zur Berechnung von Bewertungsmetriken.
• torch: Das Deep-Learning-Framework, das wir verwenden.

Schritt 1: Den eigenen Datensatz vorbereiten

Ein guter Datensatz ist der Grundstein jedes Projekts des maschinellen Lernens. Da es keinen weit verbreiteten, fertig paketierten Datensatz für kognitive Verzerrungen gibt, erstellen wir unseren eigenen. Für dieses Tutorial verwenden wir einen kleinen, von Hand erstellten Datensatz. In einem realen Szenario würden Sie einen deutlich größeren und vielfältigeren Datensatz benötigen, der idealerweise von Fachleuten annotiert wurde.

Was wir tun

Wir erstellen eine CSV-Datei mit Textbeispielen und den zugehörigen Bezeichnungen kognitiver Verzerrungen.

Implementierung

Erstellen Sie eine Datei namens cognitive_distortions.csv mit folgendem Inhalt:

text,all_or_nothing,overgeneralization,mental_filter,disqualifying_the_positive,jumping_to_conclusions,magnification_minimization,emotional_reasoning,should_statements,labeling,personalization
"I completely failed the exam. I'm a total idiot.",1,0,0,0,0,0,0,0,1,0
"She didn't text back, she must be mad at me.",0,0,0,0,1,0,0,0,0,0
"I always ruin everything.",0,1,0,0,0,0,0,0,0,0
"I got a promotion, but it was just luck.",0,0,0,1,0,0,0,0,0,0
"I feel anxious, so something terrible must be about to happen.",0,0,0,0,0,0,1,0,0,0
"He only pointed out one mistake in my presentation, so the whole thing was a disaster.",0,0,1,0,0,1,0,0,0,0
"I should be able to handle this without getting stressed.",0,0,0,0,0,0,0,1,0,0
"It's all my fault that the team project is behind schedule.",0,0,0,0,0,0,0,0,0,1
"I'm just a loser.",0,0,0,0,0,0,0,0,1,0
"This will be a catastrophe.",0,0,0,0,1,1,0,0,0,0
"I never get any recognition for my hard work.",0,1,1,0,0,0,0,0,0,0
"I'm a bad person for feeling this way.",0,0,0,0,0,0,1,0,1,0
"I ought to have known better.",0,0,0,0,0,0,0,1,0,0
"They probably think I'm incompetent.",0,0,0,0,1,0,0,0,0,1
"I made one small mistake, so I'm a complete failure.",1,0,0,0,0,1,0,0,1,0

So funktioniert es

Diese CSV-Datei hat eine Spalte text und anschließend eine binäre Spalte (0 oder 1) für jede der 10 kognitiven Verzerrungen, auf die wir abzielen. Eine „1“ zeigt an, dass diese Verzerrung im Text vorhanden ist. Dieses Format eignet sich ideal für die Mehrfachkennzeichnung.

Schritt 2: Die Daten laden und vorverarbeiten

Laden wir nun unseren Datensatz und bereiten ihn für das Modell vor.

Was wir tun

Wir verwenden die Bibliothek datasets, um unsere CSV-Datei zu laden, und tokenisieren anschließend den Text. Die Tokenisierung ist der Prozess, bei dem Rohtext in ein Format umgewandelt wird, das das Modell verstehen kann – numerische Darstellungen von Wörtern oder Teilwörtern.

Implementierung

# src/data_loader.py
import pandas as pd
from datasets import Dataset
from transformers import AutoTokenizer

def load_and_preprocess_data(file_path, model_checkpoint):
    # Daten mit pandas laden
    df = pd.read_csv(file_path)

    # Bezeichnungen vom Text trennen
    labels = [col for col in df.columns if col != 'text']
    id2label = {idx: label for idx, label in enumerate(labels)}
    label2id = {label: idx for idx, label in enumerate(labels)}
    
    # Neue Spalte 'labels' mit einer Liste binärer Werte erstellen
    df['labels'] = df[labels].values.tolist()
    
    # In ein Hugging-Face-Dataset-Objekt umwandeln
    dataset = Dataset.from_pandas(df)
    
    # Tokenizer initialisieren
    tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

    # Tokenisierungsfunktion
    def tokenize_data(examples):
        return tokenizer(examples['text'], truncation=True)

    # Tokenisierung auf den Datensatz anwenden
    dataset = dataset.map(tokenize_data, batched=True)
    
    # Datensatz für PyTorch formatieren
    dataset = dataset.map(lambda x: {'labels': [float(label) for label in x['labels']]})
    dataset.set_format("torch", columns=["input_ids", "attention_mask", "labels"])

    return dataset, id2label, label2id

# Beispielverwendung
if __name__ == '__main__':
    MODEL_CHECKPOINT = "distilbert-base-uncased"
    dataset, id2label, label2id = load_and_preprocess_data('cognitive_distortions.csv', MODEL_CHECKPOINT)
    print(dataset[0])
    print(f"id2label: {id2label}")

So funktioniert es

1. Wir laden die CSV-Datei in einen pandas-DataFrame.
2. Wir erstellen Zuordnungen zwischen Bezeichnungsnamen und ganzzahligen IDs, was eine bewährte Praxis ist.
3. Wir fassen die One-Hot-kodierten Bezeichnungen in einer einzigen Spalte labels zusammen, die eine Liste von Gleitkommazahlen enthält.
4. Wir laden den DistilBERT-Tokenizer mit AutoTokenizer.
5. Die Funktion map wendet den Tokenisierungsprozess effizient auf den gesamten Datensatz an.
6. Abschließend setzen wir das Format des Datensatzes auf „torch“, damit er direkt in einer PyTorch-Trainingsschleife verwendet werden kann.

Schritt 3: Den Mini-Transformer feinjustieren

Dies ist der Kern unseres Projekts. Wir verwenden die Trainer-API aus der Bibliothek transformers, die den Trainingsprozess erheblich vereinfacht.

Was wir tun

Wir laden das vortrainierte DistilBERT-Modell, konfigurieren die Trainingsargumente, definieren unsere Bewertungsmetriken und starten anschließend den Feinjustierungsprozess.

Implementierung

# src/train.py
import torch
from transformers import AutoModelForSequenceClassification, Trainer, TrainingArguments
from sklearn.metrics import f1_score, roc_auc_score, accuracy_score
from data_loader import load_and_preprocess_data

MODEL_CHECKPOINT = "distilbert-base-uncased"
dataset, id2label, label2id = load_and_preprocess_data('cognitive_distortions.csv', MODEL_CHECKPOINT)

# Datensatz aufteilen (in einem realen Szenario hätten Sie einen separaten Testdatensatz)
train_test_split = dataset.train_test_split(test_size=0.2)
train_dataset = train_test_split['train']
eval_dataset = train_test_split['test']

# Modell laden
model = AutoModelForSequenceClassification.from_pretrained(
    MODEL_CHECKPOINT,
    problem_type="multi_label_classification",
    num_labels=len(id2label),
    id2label=id2label,
    label2id=label2id
)

# Metriken definieren
def compute_metrics(p):
    preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions
    # Sigmoid anwenden, um Wahrscheinlichkeiten zu erhalten, und anschließend einen Schwellenwert setzen
    sigmoid = torch.nn.Sigmoid()
    probs = sigmoid(torch.Tensor(preds))
    y_pred = (probs > 0.5).int()
    y_true = p.label_ids

    f1_micro_average = f1_score(y_true=y_true, y_pred=y_pred, average='micro')
    roc_auc = roc_auc_score(y_true, y_pred, average='micro')
    accuracy = accuracy_score(y_true, y_pred)
    
    metrics = {'f1': f1_micro_average, 'roc_auc': roc_auc, 'accuracy': accuracy}
    return metrics

# Trainingsargumente definieren
training_args = TrainingArguments(
    output_dir="cognitive-distortion-model",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=10, # Erhöht für einen sehr kleinen Datensatz
    weight_decay=0.01,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

# Trainer erstellen
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=AutoTokenizer.from_pretrained(MODEL_CHECKPOINT),
    compute_metrics=compute_metrics,
)

# Training starten
trainer.train()

# Bestes Modell speichern
trainer.save_model("best_cognitive_distortion_model")

So funktioniert es

1. Wir teilen unseren kleinen Datensatz in Trainings- und Bewertungsdatensätze auf.
2. Wir laden DistilBERT mit AutoModelForSequenceClassification. Entscheidend ist, dass wir problem_type="multi_label_classification" angeben und unsere Bezeichnungszuordnungen bereitstellen.
3. Die Funktion compute_metrics legt fest, wie wir die Leistung unseres Modells während des Trainings bewerten. Für Aufgaben mit Mehrfachkennzeichnung sind Metriken wie der F1-Score (mikro-gemittelt) und die ROC-AUC sehr aussagekräftig.
4. TrainingArguments ermöglicht es uns, Hyperparameter wie Lernrate, Stapelgröße und die Anzahl der Epochen zu konfigurieren.
5. Das Objekt Trainer führt alles zusammen: das Modell, die Argumente, die Datensätze und die Bewertungsfunktion.
6. trainer.train() startet den Feinjustierungsprozess! Der Trainer übernimmt für uns die Trainingsschleife, die Gradientenaktualisierungen und die Bewertung.

Alles zusammenführen: Vorhersagen treffen

Sobald das Modell trainiert ist, sehen wir es in Aktion.

Implementierung

# src/predict.py
from transformers import pipeline

# Feinjustiertes Modell laden
model_path = "best_cognitive_distortion_model"
classifier = pipeline("text-classification", model=model_path, return_all_scores=True)

# Mit einigen Beispieltexten testen
text1 = "I can't believe I made such a stupid mistake. I'm a complete failure."
text2 = "I'm sure they are all talking about how bad my presentation was."
text3 = "This is a great achievement, but I was just lucky."

predictions1 = classifier(text1)
predictions2 = classifier(text2)
predictions3 = classifier(text3)

def display_predictions(text, predictions):
    print(f"\
Text: '{text}'")
    print("Predictions:")
    for prediction in predictions[0]:
        if prediction['score'] > 0.5: # Bezeichnungen mit hoher Konfidenz anzeigen
            print(f"  - {prediction['label']}: {prediction['score']:.4f}")

display_predictions(text1, predictions1)
display_predictions(text2, predictions2)
display_predictions(text3, predictions3)

Erwartete Ausgabe

Text: 'I can't believe I made such a stupid mistake. I'm a complete failure.'
Predictions:
  - labeling: 0.9876
  - all_or_nothing: 0.9543
  - magnification_minimization: 0.8123

Text: 'I'm sure they are all talking about how bad my presentation was.'
Predictions:
  - jumping_to_conclusions: 0.9912
  - personalization: 0.7890

Text: 'This is a great achievement, but I was just lucky.'
Predictions:
  - disqualifying_the_positive: 0.9951

Bewährte Sicherheitspraktiken

Wenn Sie ein Modell bereitstellen, das mit potenziell sensiblen Textdaten umgeht, hat Sicherheit oberste Priorität.

• Eingabevalidierung: Bereinigen und validieren Sie alle Texteingaben, um Injection-Angriffe zu verhindern, auch wenn das Modell selbst nicht direkt mit einer Datenbank verbunden ist.
• Datenschutz: Wenn Sie Benutzereingaben zur Verbesserung des Modells protokollieren, stellen Sie sicher, dass die Daten anonymisiert und sicher gespeichert werden. Seien Sie gegenüber den Nutzerinnen und Nutzern transparent, wie ihre Daten verwendet werden.
• Modellintegrität: Schützen Sie Ihre gespeicherten Modelldateien. Eine Angreiferin oder ein Angreifer, die oder der Ihre Modelldatei ersetzen kann, könnte beliebigen Code ausführen.

Tipps für die Produktionsbereitstellung

• Containerisierung: Packen Sie Ihr Modell und Ihren Vorhersagedienst (z. B. mit FastAPI) in einen Docker-Container, um einfache und reproduzierbare Bereitstellungen zu ermöglichen.
• Modellbereitstellung: Verwenden Sie ein dediziertes Werkzeug zur Modellbereitstellung wie TorchServe oder stellen Sie auf einer serverlosen Plattform wie AWS Lambda oder Google Cloud Run bereit, um skalierbare Inferenz zu ermöglichen.
• Optimierung: Erwägen Sie für Anwendungen mit hohem Durchsatz Techniken wie Quantisierung oder die ONNX-Runtime, um die Inferenz zu beschleunigen.

Fazit

Wir haben erfolgreich ein DistilBERT-Modell feinjustiert, um kognitive Verzerrungen in Texten zu erkennen und zu kennzeichnen. Sie verfügen nun über eine solide Grundlage, um fortgeschrittenere NLP-Anwendungen im Bereich der psychischen Gesundheit zu entwickeln. Dieses Projekt zeigt die Stärke des Transferlernens – ein großes, allgemein einsetzbares Modell zu nehmen und es an eine hochspezialisierte und wertvolle Aufgabe anzupassen.

Ihre nächsten Schritte:

• Den Datensatz erweitern: Die größte Verbesserung ergibt sich aus einem größeren, differenzierteren Datensatz.
• Mit anderen Modellen experimentieren: Versuchen Sie, andere Modelle wie RoBERTa oder sogar kleinere wie MobileBERT feinzujustieren, um zu sehen, wie sich Leistung und Geschwindigkeit für Ihren Anwendungsfall gegeneinander abwägen.
• Eine Benutzeroberfläche erstellen: Erstellen Sie mit Streamlit oder Flask eine einfache Webanwendung, damit Nutzerinnen und Nutzer mit Ihrem Modell interagieren können.

Ressourcen

• Offizielle Hugging-Face-Dokumentation: transformers, datasets
• DistilBERT-Paper: DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter

Kurzreferenz

Häufig gestellte Fragen

F: Wie weiß ich, ob das auf mich zutrifft? A: Besprechen Sie Ihre persönliche und familiäre Krankengeschichte mit Ihrer Ärztin oder Ihrem Arzt, um Ihre individuellen Risikofaktoren zu beurteilen und geeignete nächste Schritte festzulegen.

F: Was sollte ich meine Ärztin oder meinen Arzt fragen? A: Gute Fragen sind: „Was bedeuten meine Ergebnisse?“, „Welche Möglichkeiten habe ich?“, „Welche Lebensstiländerungen würden helfen?“ und „Wann sollte ich zur Nachkontrolle kommen?“

F: Gibt es Lebensstiländerungen, die helfen können? A: Die meisten Erkrankungen profitieren von grundlegenden Maßnahmen: ausgewogene Ernährung, regelmäßige körperliche Aktivität (150+ Minuten/Woche), erholsamer Schlaf (7–9 Stunden), Stressbewältigung und Verzicht auf Tabak.

Medizinischer Haftungsausschluss

Dieser Artikel dient ausschließlich der Aufklärung und stellt keine medizinische Beratung dar. Konsultieren Sie stets eine qualifizierte medizinische Fachperson, bevor Sie Entscheidungen über Ihre Gesundheit, Behandlung oder Versorgung treffen. Individuelle Umstände unterscheiden sich, und was für eine Person angemessen ist, muss für eine andere nicht angemessen sein.

Wenn Sie einen medizinischen Notfall erleben, rufen Sie sofort 911 (oder Ihre lokale Notrufnummer) an.