# Einführung
Große Sprachmodelle (LLMs) haben eine Vorliebe dafür, in ihren Antworten eine „blumige“, manchmal übermäßig ausführliche Sprache zu verwenden. Wenn Sie eine einfache Frage stellen, werden Sie wahrscheinlich mit Absätzen übermäßig detaillierter, enthusiastischer und komplexer Prosa überschwemmt. Dieses übliche Verhalten ist in ihrer Ausbildung verankert, da sie so optimiert sind, dass sie so hilfreich und gesprächig wie möglich sind.
Bedauerlicherweise, Ausführlichkeit ist ein schwerwiegender Aspekt, den man im Auge behalten sollte, und es kann argumentiert werden, dass er oft mit einer erhöhten Wahrscheinlichkeit eines größeren Issues zusammenhängt: Halluzinationen. Je mehr Wörter in einer Antwort generiert werden, desto höher ist die Wahrscheinlichkeit, dass man vom fundierten Wissen abweicht und sich in die „Kunst des Erfindens“ wagt.
Zusammenfassend lässt sich sagen, dass robuste Leitplanken erforderlich sind, um dieses doppelseitige Downside zu verhindern, beginnend mit Ausführlichkeitsprüfungen. Dieser Artikel zeigt, wie man das verwendet Textstat Python-Bibliothek zur Messung der Lesbarkeit und Erkennung übermäßig komplexer Antworten, bevor sie den Endbenutzer erreichen, wodurch das Modell gezwungen wird, seine Antwort zu verfeinern.
# Mit Textstat ein Komplexitätsbudget festlegen
Die Textstat-Python-Bibliothek kann zur Berechnung von Scores wie dem Automated Readability Index (ARI) verwendet werden. Es schätzt die Notenstufe (Studienniveau), die erforderlich ist, um einen Textual content, beispielsweise eine Modellantwort, zu verstehen. Wenn diese Komplexitätsmetrik ein Price range oder einen Schwellenwert überschreitet – beispielsweise 10,0, was einem Leseniveau der 10. Klasse entspricht – kann automatisch eine erneute Aufforderungsschleife ausgelöst werden, um eine prägnantere und einfachere Antwort zu erfordern. Diese Strategie vertreibt nicht nur blumige Sprache, sondern kann auch dazu beitragen, das Risiko von Halluzinationen zu verringern, da sich das Modell dadurch strenger an Kernfakten hält.
# Implementierung der LangChain-Pipeline
Sehen wir uns an, wie wir die oben beschriebene Strategie umsetzen und in eine integrieren können LangChain Pipeline, die problemlos in einem Google Colab-Notizbuch ausgeführt werden kann. Sie benötigen eine Umarmendes Gesicht API-Token, kostenlos erhältlich unter https://huggingface.co/settings/tokens. Erstellen Sie ein neues „Geheimnis“ mit dem Namen HF_TOKEN Klicken Sie im Menü auf der linken Seite von Colab auf das Image „Geheimnisse“ (es sieht aus wie ein Schlüssel). Fügen Sie das generierte API-Token in das Feld „Wert“ ein und schon sind Sie startklar!
Installieren Sie zunächst die erforderlichen Bibliotheken:
!pip set up textstat langchain_huggingface langchain_communityDer folgende Code ist Google Colab-spezifisch und Sie müssen ihn möglicherweise entsprechend anpassen, wenn Sie in einer anderen Umgebung arbeiten. Der Schwerpunkt liegt auf der Wiederherstellung des gespeicherten API-Tokens:
from google.colab import userdata
# Acquire Hugging Face API token saved in your Colab session's Secrets and techniques
HF_TOKEN = userdata.get('HF_TOKEN')
# Confirm token restoration
if not HF_TOKEN:
print("WARNING: The token 'HF_TOKEN' wasn't discovered. This will likely trigger errors.")
else:
print("Hugging Face Token loaded efficiently.")Im folgenden Codeabschnitt führen wir mehrere Aktionen aus. Zunächst richtet es Komponenten für die lokale Textgenerierung über ein vorab trainiertes Hugging-Face-Modell ein – und zwar speziell distilgpt2. Anschließend wird das Modell in eine LangChain-Pipeline integriert.
import textstat
from langchain_core.prompts import PromptTemplate
# Importing essential lessons for native Hugging Face pipelines
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain_community.llms import HuggingFacePipeline
# Initializing a free-tier, local-friendly, appropriate LLM for textual content era
model_id = "distilgpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
mannequin = AutoModelForCausalLM.from_pretrained(model_id)
# Making a text-generation pipeline
pipe = pipeline(
"text-generation",
mannequin=mannequin,
tokenizer=tokenizer,
max_new_tokens=100,
gadget=0 # Use GPU if obtainable, in any other case it would default to CPU
)
# Wrapping the pipeline in HuggingFacePipeline
llm = HuggingFacePipeline(pipeline=pipe)Als Nächstes wird unser Kernmechanismus zum Messen und Verwalten der Ausführlichkeit implementiert. Die folgende Funktion generiert eine Zusammenfassung des an sie übergebenen Textes (angenommen, es handelt sich um eine LLM-Antwort) und versucht sicherzustellen, dass die Zusammenfassung einen Komplexitätsschwellenwert nicht überschreitet. Beachten Sie, dass bei Verwendung einer geeigneten Eingabeaufforderungsvorlage Generierungsmodelle wie z distilgpt2 kann zum Erhalten von Textzusammenfassungen verwendet werden, obwohl die Qualität solcher Zusammenfassungen möglicherweise nicht mit der von umfangreicheren, auf Zusammenfassungen ausgerichteten Modellen mithalten kann. Wir haben dieses Modell aufgrund seiner Zuverlässigkeit für die lokale Ausführung in einer eingeschränkten Umgebung ausgewählt.
def safe_summarize(text_input, complexity_budget=10.0):
print("n--- Beginning Abstract Course of ---")
print(f"Enter textual content size: {len(text_input)} characters")
print(f"Goal complexity finances (ARI rating): {complexity_budget}")
# Step 1: Preliminary Abstract Era
print("Producing preliminary complete abstract...")
base_prompt = PromptTemplate.from_template(
"Present a complete abstract of the next: {textual content}"
)
chain = base_prompt | llm
abstract = chain.invoke({"textual content": text_input})
print("Preliminary Abstract generated:")
print("-------------------------")
print(abstract)
print("-------------------------")
# Step 2: Measure Readability
ari_score = textstat.automated_readability_index(abstract)
print(f"Preliminary ARI Rating: {ari_score:.2f}")
# Step 3: Implement Complexity Price range
if ari_score > complexity_budget:
print("Price range exceeded! Preliminary abstract is just too complicated.")
print("Triggering simplification guardrail...")
simplification_prompt = PromptTemplate.from_template(
"The next textual content is just too verbose. Rewrite it concisely "
"utilizing easy vocabulary, stripping away flowery language:nn{textual content}"
)
simplify_chain = simplification_prompt | llm
simplified_summary = simplify_chain.invoke({"textual content": abstract})
new_ari = textstat.automated_readability_index(simplified_summary)
print("Simplified Abstract generated:")
print("-------------------------")
print(simplified_summary)
print("-------------------------")
print(f"Revised ARI Rating: {new_ari:.2f}")
abstract = simplified_summary
else:
print("Preliminary abstract is inside complexity finances. No simplification wanted.")
print("--- Abstract Course of Completed ---")
return abstractBeachten Sie auch im obigen Code, dass ARI-Scores berechnet werden, um die Textkomplexität abzuschätzen.
Der letzte Teil des Codebeispiels testet die zuvor definierte Funktion, übergibt Beispieltext und ein Komplexitätsbudget von 10,0 und gibt die Endergebnisse aus.
# 1. Offering some extremely verbose, complicated pattern textual content
sample_text = """
The inextricably intertwined permutations of cognitive computational arrays throughout the
realm of Massive Language Fashions typically precipitate a cascade of unnecessarily labyrinthine
lexical constructions. This propensity for circumlocution, while seemingly indicative of
profound erudition, continuously obfuscates the foundational semantic payload, thereby
rendering the generated discourse considerably much less accessible to the quintessential layperson.
"""
# 2. Calling the perform
print("Working summarizer pipeline...n")
final_output = safe_summarize(sample_text, complexity_budget=10.0)
# 3. Printing the ultimate consequence
print("n--- Remaining Guardrailed Abstract ---")
print(final_output)Die resultierenden gedruckten Nachrichten können recht lang sein, aber Sie werden einen leichten Rückgang des ARI-Scores feststellen, nachdem Sie das vorab trainierte Modell zur Zusammenfassung aufgerufen haben. Erwarten Sie jedoch keine wundersamen Ergebnisse: Das gewählte Modell ist zwar leichtgewichtig, eignet sich jedoch nicht besonders intestine für die Zusammenfassung von Texten, sodass die Reduzierung der ARI-Punktzahl eher bescheiden ausfällt. Sie können versuchen, andere Modelle zu verwenden, z google/flan-t5-small um zu sehen, wie sie bei der Textzusammenfassung funktionieren, aber seien Sie gewarnt – diese Modelle werden schwerer und schwieriger auszuführen sein.
# Zusammenfassung
In diesem Artikel wird gezeigt, wie Sie eine Infrastruktur zum Messen und Steuern übermäßig ausführlicher LLM-Antworten implementieren, indem Sie ein Hilfsmodell aufrufen, um sie zusammenzufassen, bevor ihr Komplexitätsgrad genehmigt wird. Halluzinationen sind in vielen Szenarien ein Nebenprodukt hoher Ausführlichkeit. Während sich die hier gezeigte Implementierung auf die Beurteilung der Ausführlichkeit konzentriert, gibt es spezifische Prüfungen, die auch zur Messung von Halluzinationen verwendet werden können – wie z. B. semantische Konsistenzprüfungen, Cross-Encoder für natürliche Sprachinferenz (NLI) und LLM-als-Richter-Lösungen.
Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.