Gliederungen: erzeugt strukturierte Textausgaben über reguläre Ausdrücke, JSON oder Pydantic-Modelle

Allgemeine Einführung

Outlines ist eine Open-Source-Bibliothek, die von dottxt-ai entwickelt wurde, um die Anwendung von Large Language Models (LLM) durch strukturierte Textgenerierung zu verbessern. Die Bibliothek unterstützt mehrere Modellintegrationen, einschließlich OpenAI, Transformatoren, llama.cpp usw. Sie bietet einfache, aber leistungsfähige Prompt-Primitive und basiert auf der Jinja Template Engine. Outlines ermöglicht dem Benutzer eine schnelle Generierung über reguläre Ausdrücke, JSON-Patterns oder Pydantic-Modelle und unterstützt eine Vielzahl von Sampling-Algorithmen wie Greedy-Algorithmen, polynomiales Sampling und Bündelsuche. Das Projekt bietet auch Funktionen wie Cache-Generierung, Batch-Inferenz usw., um die Geschwindigkeit und Leistung der Modellinferenz zu verbessern.Outlines wurde in Funktionsaufrufen von gängigen Inferenz-Frameworks (z. B. VLLM, TGI) verwendet.

Funktionsliste

• Multi-Modell-Integration: unterstützt OpenAI, Transformatoren, llama.cpp und andere Modelle.
• Einfache und leistungsstarke Hinweise: basierend auf der Jinja Template Engine.
• Generierung von Strukturen für reguläre Ausdrücke: Schnelles Generieren von Text, der regulären Ausdrücken entspricht
• JSON-Generierung: Generierung von Text auf der Grundlage von JSON-Schemata oder Pydantic-Modellen
• Generierung von Syntaxstrukturen: Unterstützung für Schleifen, Konditionale und benutzerdefinierte Python-Funktionen
• Cache generieren: Ergebnisse der Cache-Generierung zur Verbesserung der Effizienz
• Batch Reasoning: Unterstützung der Stapelverarbeitung, um die Geschwindigkeit des Reasonings zu erhöhen
• Mehrere Sampling-Algorithmen: Unterstützt Greedy-, Polynomial- und Beam-Search-Sampling-Algorithmen.
• Docker-Unterstützung: Bereitstellung offizieller Docker-Images für eine einfache Bereitstellung.

Hilfe verwenden

Ablauf der Installation

1. Stellen Sie sicher, dass die Python-Umgebung installiert ist.
2. Installieren Sie Outlines mit pip:

   pip install outlines

3. Wenn Sie die Kernfunktionen der Rust-Version verwenden möchten, können Sie outlines-core installieren:

   pip install outlines-core

Richtlinien für die Verwendung

Grundlegende Verwendung

1. Importieren Sie die Gliederungsbibliothek:

   Umrisse einführen

2. Wählen und laden Sie das Modell:

   model = outlines.models.transformers("openai/gpt-3.5-turbo")

3. Erstellen Sie Prompts und generieren Sie Text:

   prompt = "Erstelle eine kurze Einführung in die KI-Technologie."
generated_text = model.generate(prompt)
print(generierter_text)

Erweiterte Funktionen

1. Generierung von strukturiertem Text mit regulären Ausdrücken:

   outlines importieren
generator = outlines.generate.regex("^[A-Z][a-z]+$")
result = generator("Erzeuge ein Wort, das auf den regulären Ausdruck passt")
print(ergebnis)

2. Generieren Sie Text mit Hilfe des JSON-Schemas:

   importieren Sie Umrisse
from pydantic import BaseModel
class Person(BaseModel): name: str
Name: str
Alter: int
generator = outlines.generate.json(Person)
result = generator({"name": "Alice", "age": 30})
ergebnis = generator({"name": "Alice", "alter": 30})

3. Es werden mehrere Stichprobenalgorithmen verwendet:

   outlines importieren
generator = outlines.generate.choice(model, ["option1", "option2", "option3"])
result = generator("Bitte wählen Sie eine Option aus:")
print(ergebnis)

4. Stellen Sie ein Docker-Image bereit:

   docker pull outlinesdev/outlines
docker run -p 8000:8000 outlinesdev/outlines

allgemeine Probleme

• Wie kann ich die Geschwindigkeit der Generierung erhöhen? Die Geschwindigkeit der Generierung kann durch die Verwendung von Batch-Inferenz und die Generierung von Cache-Funktionen erheblich verbessert werden.
• Wie lassen sich benutzerdefinierte Funktionen integrieren? Benutzerdefinierte Python-Funktionen können verwendet werden, um komplexe Logik während der Generierung zu behandeln.

Probleme durch unstrukturierten Output von großen Modellen

Ausgaben

Große Sprachmodelle (Large Language Models, LLMs) haben starke Fähigkeiten zur Texterzeugung, sind aber nicht zuverlässig genug bei der Erzeugung strukturierter Daten. Dies stellt ein ernstes Problem für agentenorientierte KI-Anwendungen dar.

Zentrale Themen

• Unstimmigkeiten bei der AusgabeBeim Extrahieren von Fluginformationen aus E-Mails wäre es ideal, konsistente JSON-Objekte auszugeben, aber LLM versagt oft, was zu Problemen wie "JSON decode errors" führt.
• Mangelnde ZuverlässigkeitDiese Unvorhersehbarkeit macht es schwierig, komplexe modulare Systeme auf der Grundlage von LLM zu entwickeln.

beeinflussen (in der Regel nachteilig)

Ohne eine zuverlässige strukturierte Ausgabe müssen die Entwickler die Informationen durch mühsame Nachbearbeitung (z. B. reguläre Ausdrücke) extrahieren, was zu einer ineffizienten und fehleranfälligen Entwicklung führt.

Vorteile der strukturierten Ausgabe

Allgemeine Struktur der Daten

Selbst scheinbar unstrukturierte Daten (z. B. GSM-Datensätze) weisen oft eine inhärente Struktur auf, die es zu nutzen gilt.

Garantiertes Ausgabeformat

Durch die Definition spezifischer Strukturen (z. B. JSON oder reguläre Ausdrücke) können Sie die Gültigkeit der Ausgabe sicherstellen und mühsame Nachbearbeitungen vermeiden.

Verbesserung von Leistung und Effizienz

• Verbesserung der JSON-EffizienzJSON-Effizienz stieg von 17,7% auf 99,9% bei strukturierter Generierung.
• Geringerer Bedarf an BeispielenBeim GSM8K-Benchmarking ist die Leistung der einmaligen strukturierten Generierung fast vergleichbar mit der achtmaligen unstrukturierten Generierung.
• Verbesserung der Leistung offener ModelleBeim Funktionsaufruf-Benchmark verbessert sich die Leistung von 86% auf 96,5% und übertrifft damit sogar GPT-4.

Strukturierte versus unstrukturierte Ausgaben

Um die Vorteile der strukturierten Ausgabe besser zu verstehen, können wir die Unterschiede zwischen strukturierter und unstrukturierter Ausgabe anhand des folgenden Beispiels vergleichen.

Angenommen, wir müssen Fluginformationen aus einer E-Mail extrahieren:

unstrukturierte Ausgabe

Wenn die von einem großen Modell erzeugte Ausgabe nicht streng formatiert ist, kann man den folgenden Text erhalten:

Der Flug nach Paris geht am nächsten Dienstag, wahrscheinlich um 10 Uhr morgens, mit der Air France.

Diese Ausgabe enthält zwar die von uns benötigten Informationen (Zielort, Datum, Uhrzeit, Fluggesellschaft usw.), hat aber keine klare Struktur. Um diese Informationen zu extrahieren, muss der Entwickler die einzelnen Felder mit regulären Ausdrücken oder anderen Textverarbeitungsmethoden analysieren, was sowohl mühsam als auch fehleranfällig ist. So ist es beispielsweise möglich, dass das Modell für verschiedene Eingaben unterschiedlich formatierte Ausgaben liefert, was zu Systemverarbeitungsfehlern oder "JSON-Decodierfehlern" führt.

Strukturierte Ausgabe

Bei der strukturierten Generierung gibt das Modell Daten zurück, die z. B. einem vordefinierten Format entsprechen:

{
  "Ziel": "Paris".
  "departure_date": "2024-11-25",
  "Uhrzeit": "10:00",
  "Fluggesellschaft": "Air France"
}

In diesem Fall ist die Ausgabe einheitlich und standardisiert. Der Entwickler muss die Informationen nicht mehr zusätzlich verarbeiten oder parsen, da alle Schlüsselfelder bereits in dem erwarteten Format zurückgegeben werden. Das spart nicht nur Entwicklungszeit, sondern verringert auch die Fehlerwahrscheinlichkeit erheblich.

Anhand dieses Vergleichs wird deutlich, dass eine strukturierte Ausgabe nicht nur die Konsistenz und Zuverlässigkeit der Daten gewährleistet, sondern auch die Verarbeitungseffizienz erheblich verbessert, insbesondere wenn eine große Menge an Informationen aus einem großen Modell extrahiert und verarbeitet werden muss.

Verursacht die Verwendung von Gliederungen Leistungsprobleme bei großen Modellen?

Wie funktioniert die Gliederung?

Begründung

• Logit-VerarbeitungOutlines: Nachdem das Modell Logits generiert hat, prüft Outlines jedes mögliche nächste Token und blockiert diejenigen, die die definierte Struktur verletzen.
• Optimierung der EffizienzExtrem niedriger zusätzlicher Overhead durch effiziente Maskierung.

typisches Beispiel

"Wenn die erzeugten Token die Struktur zerstören würde, wird sie sofort blockiert, um sicherzustellen, dass sich der Generierungsprozess strikt an die vorgegebene Struktur hält."

Verlangsamt eine strukturierte Ausgabe die Ausgabe?

Das ist nicht der Fall. Im Gegenteil, die strukturierte Erzeugung beschleunigt in der Regel den Erzeugungsprozess:

• Reduzierung der nutzlosen TokenVermeiden Sie die Erzeugung redundanter Feldnamen oder Klammern, indem Sie die Struktur im Voraus definieren.
• Verkürzte GenerationsdauerStrukturierte Ausgaben haben in der Regel weniger Token, sind schneller und übersichtlicher.

Vergleich von Outlines mit anderen strukturierten Generierungsbibliotheken

• Vergleich mit GuidanceOutlines hat fast keinen Overhead in der Inferenzphase, während Guidance bei der Generierung einer großen Anzahl von Token deutlich langsamer werden kann.
• Vergleich mit LMQLOutlines: Die wichtigsten Stärken des Outlines sind sein geringes Gewicht und seine Effizienz.

Code-Beispiel

Im Folgenden finden Sie ein Beispiel für die Verwendung von Gliederungen zur Erzeugung strukturierter Ereignisdaten:

from datetime importieren datetime
from pydantic importieren BaseModel, Feld
from outlines import generate, models

# Modell laden
model = models.mlxlm("mlx-community/Hermes-3-Llama-3.1-8B-8bit")

# definiert die Ereignisstruktur mit Pydantic
class Event(BaseModel).
    title: str = Field(description="Titel des Ereignisses")
    Ort: str
    start: datetime = Feld(
        default=None, description="Datum des Ereignisses, falls im iso-Format verfügbar")
    )

# Aktuelle Zeit abrufen
now = datetime.now().strftime("%A %d %B %Y und es ist %H:%M")

# Eingabeaufforderung definieren
prompt = f"""
Das heutige Datum und die heutige Uhrzeit sind {now}
Extrahiere aus einer Benutzernachricht Informationen über das Ereignis wie Datum und Uhrzeit im Iso-Format, Ort und Titel.
Wenn das angegebene Datum relativ ist, denken Sie Schritt für Schritt, um das richtige Datum zu finden.
Hier ist die Nachricht.
"""

# Beispielnachricht
message = """Hallo Kitty, meine Großmutter wird hier sein. Ich denke, es ist besser, unsere Verabredung zur Wiederholung des Matheunterrichts auf nächsten Freitag um 14 Uhr am selben Ort in der Avenue 3 zu verschieben.
Wir verschieben den Termin für die Wiederholung des Matheunterrichts auf nächsten Freitag, 14 Uhr, am selben Ort, 3 avenue des tanneurs, ich denke, eine Stunde wird ausreichen.
Wir sehen uns 😘😘😘😘😘 """

# Erstellen Sie den Generator
generator = generate.json(model, Event)

# Extrahieren der Ereignismeldung
event = generator(prompt + message)

# Ausgabe des Ergebnisses
print(f "Heute: {jetzt}")
print(event.json())

Die generierten Ereignisinformationen lauten wie folgt:

{
  "Titel": "Matheprüfung".
  "location": "3 avenue des tanneurs".
  "start": "2024-11-22T14:00:00Z"
}

Schlussfolgerungen und Ausblick

Die strukturierte Erstellung ist nicht mehr nur eine Nischenfunktion, sondern die Zukunft großer Modellanwendungen:

• Höhere Zuverlässigkeit und EffizienzDie Leistung des LLM wird durch die strukturierte Erzeugung erheblich verbessert.
• Das Potenzial von Open SourceDer Erfolg von Outlines zeigt das Potenzial von Open-Source-Modellen im Wettbewerb mit proprietären Modellen.

Es wird erwartet, dass Outlines in Zukunft eine Schlüsselkomponente im Werkzeugkasten des Entwicklers sein wird, da strukturierte Generierung immer häufiger vorkommt.