Strategien zur Kontrolle von Übermaß und Halluzinationen bei KI-Texten

In diesem Artikel wird erörtert, wie eine Infrastruktur zur Messung und Kontrolle von übermäßig ausführlichen Antworten großer Sprachmodelle (LLMs) implementiert werden kann.

Einleitung

Große Sprachmodelle neigen dazu, in ihren Antworten eine blumige und manchmal übermäßig ausführliche Sprache zu verwenden. Stellt man eine einfache Frage, erhält man häufig lange Absätze mit übermäßig detaillierten, enthusiastischen und komplexen Formulierungen. Dieses Verhalten ist auf ihre Trainingsmethoden zurückzuführen, da sie darauf optimiert sind, so hilfreich und gesprächig wie möglich zu sein.

Leider ist die Ausführlichkeit ein ernstzunehmendes Problem, das oft mit einem erhöhten Risiko für ein gravierendes Problem korreliert: Halluzinationen. Je mehr Wörter in einer Antwort generiert werden, desto höher ist die Wahrscheinlichkeit, dass vom fundierten Wissen abgewichen wird und in die „Kunst der Fälschung“ abgedriftet wird.

Zusammenfassend lässt sich sagen, dass robuste Leitplanken erforderlich sind, um dieses doppelte Problem zu verhindern, beginnend mit der Überprüfung der Ausführlichkeit. Dieser Artikel zeigt, wie die Textstat-Python-Bibliothek verwendet werden kann, um die Lesbarkeit zu messen und übermäßig komplexe Antworten zu erkennen, bevor sie den Endbenutzer erreichen, und das Modell zu zwingen, seine Antwort zu verfeinern. Zudem können leistungsstarke Python-Dekoratoren helfen, die Effizienz von LLM-Anwendungen zu optimieren.

Festlegung eines Komplexitätsbudgets mit Textstat

Die Textstat-Python-Bibliothek kann verwendet werden, um Werte wie den automatisierten Lesbarkeitsindex (ARI) zu berechnen; dieser schätzt das erforderliche Bildungsniveau, um einen Text, wie beispielsweise eine Modellantwort, zu verstehen. Wenn dieser Komplexitätswert ein Budget oder einen Schwellenwert überschreitet – beispielsweise 10,0, was einem Leseverständnis auf 10. Klassen-Niveau entspricht – kann automatisch eine Wiederaufforderungsschleife ausgelöst werden, um eine prägnantere, einfachere Antwort zu verlangen. Diese Strategie beseitigt nicht nur blumige Sprache, sondern kann auch dazu beitragen, das Risiko von Halluzinationen zu verringern, da das Modell strenger an den Kernfakten festhält.

Implementierung der LangChain-Pipeline

Im Folgenden wird gezeigt, wie die oben beschriebene Strategie implementiert und in eine LangChain-Pipeline integriert werden kann, die einfach in einem Google Colab-Notizbuch ausgeführt werden kann. Zunächst benötigen Sie ein Hugging Face API-Token, das kostenlos unter https://huggingface.co/settings/tokens erhältlich ist. Erstellen Sie ein neues „Secret“ mit dem Namen HF_TOKEN im linken Menü von Colab, indem Sie auf das „Secrets“-Symbol (es sieht aus wie ein Schlüssel) klicken. Fügen Sie das generierte API-Token in das Feld „Wert“ ein, und Sie sind bereit!

Um zu beginnen, installieren Sie die erforderlichen Bibliotheken:

!pip install textstat langchain_huggingface langchain_community

Der folgende Code ist spezifisch für Google Colab, und Sie müssen ihn möglicherweise anpassen, wenn Sie in einer anderen Umgebung arbeiten. Er konzentriert sich darauf, das gespeicherte API-Token abzurufen:

from google.colab import userdata
# Hugging Face API-Token aus den Secrets der Colab-Sitzung abrufen
HF_TOKEN = userdata.get('HF_TOKEN')
# Überprüfen der Token-Wiederherstellung
if not HF_TOKEN:
 print("WARNUNG: Das Token 'HF_TOKEN' wurde nicht gefunden. Dies kann zu Fehlern führen.")
else:
 print("Hugging Face Token erfolgreich geladen.")

Im folgenden Codeabschnitt führen wir mehrere Aktionen durch. Zunächst richten wir Komponenten für die lokale Textgenerierung über ein vortrainiertes Hugging Face-Modell – speziell distilgpt2 – ein. Danach wird das Modell in eine LangChain-Pipeline integriert.

import textstat
from langchain_core.prompts import PromptTemplate
# Notwendige Klassen für lokale Hugging Face-Pipelines importieren
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain_community.llms import HuggingFacePipeline
# Initialisierung eines kostenlosen, lokal kompatiblen LLM für die Textgenerierung
model_id = "distilgpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
# Erstellen einer Textgenerierungspipeline
pipe = pipeline(
 "text-generation", 
 model=model, 
 tokenizer=tokenizer, 
 max_new_tokens=100,
 device=0 # Verwenden Sie die GPU, wenn verfügbar, andernfalls wird standardmäßig die CPU verwendet
)
# Verpacken der Pipeline in HuggingFacePipeline
llm = HuggingFacePipeline(pipeline=pipe)

Unser zentrales Mechanismus zur Messung und Verwaltung der Ausführlichkeit wird als Nächstes implementiert. Die folgende Funktion generiert eine Zusammenfassung des übergebenen Textes (angenommen, es handelt sich um eine Antwort eines LLM) und versucht sicherzustellen, dass die Zusammenfassung einen festgelegten Komplexitätsgrad nicht überschreitet. Beachten Sie, dass bei Verwendung einer geeigneten Eingabeaufforderung Modelle wie distilgpt2 zur Erstellung von Textzusammenfassungen verwendet werden können, obwohl die Qualität solcher Zusammenfassungen möglicherweise nicht mit der von schwereren, auf Zusammenfassungen fokussierten Modellen übereinstimmt. Wir haben dieses Modell aufgrund seiner Zuverlässigkeit für die lokale Ausführung in einer eingeschränkten Umgebung gewählt.

def safe_summarize(text_input, complexity_budget=10.0):
 print("\n--- Zusammenfassungsprozess starten ---")
 print(f"Eingabetextlänge: {len(text_input)} Zeichen")
 print(f"Ziel-Komplexitätsbudget (ARI-Score): {complexity_budget}")
 # Schritt 1: Erste Zusammenfassung generieren
 print("Generiere erste umfassende Zusammenfassung...")
 base_prompt = PromptTemplate.from_template(
 "Geben Sie eine umfassende Zusammenfassung des Folgenden an: {text}"
 )
 chain = base_prompt | llm
 summary = chain.invoke({"text": text_input})
 print("Erste Zusammenfassung generiert:")
 print("-------------------------")
 print(summary)
 print("-------------------------")
 # Schritt 2: Lesbarkeit messen
 ari_score = textstat.automated_readability_index(summary)
 print(f"Erster ARI-Score: {ari_score:.2f}")
 # Schritt 3: Komplexitätsbudget durchsetzen
 if ari_score > complexity_budget:
 print("Budget überschritten! Erste Zusammenfassung ist zu komplex.")
 print("Auslösen der Vereinfachungsleitplanke...")
 simplification_prompt = PromptTemplate.from_template(
 "Der folgende Text ist zu ausführlich. Schreiben Sie ihn prägnant um, 
 unter Verwendung einfacher Sprache und entfernen Sie blumige Formulierungen:

{text}"
 )
 simplify_chain = simplification_prompt | llm
 simplified_summary = simplify_chain.invoke({"text": summary})
 new_ari = textstat.automated_readability_index(simplified_summary)
 print("Vereinfachte Zusammenfassung generiert:")
 print("-------------------------")
 print(simplified_summary)
 print("-------------------------")
 print(f"Überarbeiteter ARI-Score: {new_ari:.2f}")
 summary = simplified_summary
 else:
 print("Erste Zusammenfassung liegt innerhalb des Komplexitätsbudgets. Keine Vereinfachung erforderlich.")
 print("--- Zusammenfassungsprozess abgeschlossen ---")
 return summary

Beachten Sie auch im obigen Code, dass ARI-Werte berechnet werden, um die Textkomplexität zu schätzen.

Test der Funktion

Der letzte Teil des Codebeispiels testet die zuvor definierte Funktion, indem er Beispieltext und ein Komplexitätsbudget von 10,0 übergibt und die endgültigen Ergebnisse ausgibt.

• Bereitstellung eines hochgradig ausführlichen, komplexen Beispieltextes:

sample_text = """
Die untrennbar miteinander verbundenen Permutationen kognitiver Rechenarrays im Bereich der 
Großen Sprachmodelle führen oft zu einer Kaskade unnötig labyrinthartiger 
lexikalischer Strukturen. Diese Neigung zur Umschweifigkeit, obwohl sie scheinbar auf 
profounde Gelehrsamkeit hindeutet, verschleiert häufig die grundlegende semantische 
Last, wodurch die erzeugte Diskurse für den typischen Laien erheblich weniger zugänglich wird.
"""

• Aufruf der Funktion:

print("Starte Zusammenfassungs-Pipeline...\n")
final_output = safe_summarize(sample_text, complexity_budget=10.0)

• Ausgabe des endgültigen Ergebnisses:

print("\n--- Endgültige Zusammenfassung mit Leitplanken ---")
print(final_output)

Die resultierenden gedruckten Nachrichten können recht lang sein, aber Sie werden einen subtilen Rückgang des ARI-Wertes nach dem Aufruf des vortrainierten Modells zur Zusammenfassung feststellen. Erwarten Sie jedoch keine Wunder: Das gewählte Modell, obwohl leichtgewichtig, ist nicht besonders gut im Zusammenfassen von Texten, sodass die Reduzierung des ARI-Wertes eher bescheiden ausfällt. Sie können versuchen, andere Modelle wie google/flan-t5-small zu verwenden, um zu sehen, wie sie bei der Textzusammenfassung abschneiden, aber seien Sie gewarnt – diese Modelle sind schwerer und schwieriger auszuführen.

Fazit

Dieser Artikel zeigt, wie eine Infrastruktur zur Messung und Kontrolle von übermäßig ausführlichen Antworten von LLMs implementiert werden kann, indem ein Hilfsmodell zur Zusammenfassung aufgerufen wird, bevor das Niveau der Komplexität genehmigt wird. Halluzinationen sind in vielen Szenarien ein Nebenprodukt hoher Ausführlichkeit. Während die hier gezeigte Implementierung sich auf die Bewertung der Ausführlichkeit konzentriert, gibt es spezifische Überprüfungen, die auch zur Messung von Halluzinationen verwendet werden können – wie semantische Konsistenzprüfungen, natürliche Sprachinferenz (NLI) Kreuzencoder und LLM-als-Richter-Lösungen.

Iván Palomares Carrascosa ist ein führender Experte, Autor, Redner und Berater im Bereich KI, maschinelles Lernen, tiefes Lernen und LLMs. Er schult und leitet andere dabei, KI in der realen Welt zu nutzen.

Erhalten Sie das KOSTENLOSE E-Book ‚KDnuggets Artificial Intelligence Pocket Dictionary‘ zusammen mit dem führenden Newsletter zu Data Science, Machine Learning, KI und Analytics direkt in Ihr Postfach.

Durch das Abonnieren akzeptieren Sie die Datenschutzrichtlinie von KDnuggets.

„`

Quellen: kdnuggets

Bildquelle: KI generiert

KI Snack