In meinem Neuester Beitrag zu strukturierten Ausgabendie drei Hauptansätze, um maschinenlesbare Antworten von einem LLM zu erhalten. Dies sind der JSON-Modus, Funktionsaufrufe und die strukturierten Ausgaben von OpenAI. Wenn Sie diesen Beitrag noch nicht gelesen haben, lohnt es sich, ihn vor diesem Beitrag kurz zu lesen, da wir direkt darauf aufbauen.

Deshalb gehen wir heute noch einen Schritt weiter und sprechen über etwas, das die Artwork und Weise verändert, wie sich strukturierte Ausgaben in der Praxis anfühlen. Das heißt Pydantisch. Genauer gesagt, während Strukturierte Ausgaben von OpenAI Obwohl die Funktion garantiert, dass das Modell gültiges, schemakonformes JSON zurückgibt, müssen wir auf der Python-Seite noch etwas mit diesem JSON tun. Insbesondere müssen wir es analysieren, die Datentypen validieren, auf die Felder zugreifen, mit unerwarteten Werten umgehen und so weiter. Und hier kommt Pydantic ins Spiel.

Meiner Meinung nach ist die Kombination von Pydantic und OpenAIs Structured Outputs das derzeit sauberste Setup für die Erstellung zuverlässiger LLM-basierter Anwendungen in Python. Am Ende dieses Beitrags werden Sie genau sehen, warum.

Was ist mit Pydantic?

Pydantisch ist eine Python-Bibliothek zur Datenvalidierung mithilfe von Typanmerkungen. Dies bedeutet, dass Sie die Kind und Typen Ihrer Daten als Python-Klasse definieren und dann überprüfen können, ob alle von Ihnen übergebenen Daten tatsächlich dieser Beschreibung entsprechen. Wenn dies nicht der Fall ist, meldet Pydantic einen eindeutigen, beschreibenden Fehler, anstatt zuzulassen, dass sich fehlerhafte Daten stillschweigend durch Ihr System verbreiten.

Hier ist das einfachste mögliche Pydantic-Modell:

from pydantic import BaseModel

class PersonInfo(BaseModel):
    title: str
    age: int
    metropolis: str

Auf diese Weise haben wir jetzt ein Schema, das dies durchsetzt title Und metropolis werden immer eine Zeichenfolge sein, wohingegenage ist immer eine ganze Zahl. Wenn jemand versucht, eine zu erstellen PersonInfo mit age="thirty-two" Pydantic wird es sofort erkennen und uns genau sagen, was schief gelaufen ist.

Aber ist das nicht genau das, was wir bereits mit Funktionsaufrufen und strukturierten Ausgaben gemacht haben? Ja, aber mit einem sehr wichtigen Unterschied.

Einerseits kann das Modell im JSON-Modus oder beim Funktionsaufruf eine Antwort zurückgeben, die dem Schema entspricht, das wir uns vorgestellt haben, oder auch nicht. Selbst wenn das Schema richtig ist, gibt es immer noch eine einfache JSON-Zeichenfolge zurück, sodass wir Felder manuell analysieren, Typen umwandeln und Werte auf der Python-Seite validieren müssen.

Auf der anderen Seite verbessert Structured Outputs dies, indem es dank der eingeschränkten Dekodierung auf Modellebene garantiert, dass der zurückgegebene JSON immer unserem definierten Schema entspricht. Dennoch ist es immer noch nur eine JSON-Zeichenfolge, die wir in Python selbst verwalten müssen.

Mit Pydantic definieren wir unser Schema als Python-Klasse, und die Integration mit der OpenAI-API bedeutet, dass wir zurückkommen ein richtiges Python-Objekt, kein Wörterbuchwobei alle Felder automatisch eingegeben und validiert werden. Das JSON-Schema, das die API benötigt, wird hinter den Kulissen aus unserem Pydantic-Modell generiert. Wir müssen es nie selbst schreiben. Mit anderen Worten, Pydantic ist die Schemadefinitionsschicht, die zwischen unserem Python-Code und der OpenAI-API liegtDadurch wird das gesamte strukturierte Ausgabeerlebnis sauberer, sicherer und wartbarer.

DataCream ist ein Publication zu KI, Daten und Technologie. Wenn Sie sich für diese Themen interessieren, Abonnieren Sie hier!

Aber sehen wir uns in der Praxis an, was wir durch die Verwendung von Pydantic im Vergleich zur bloßen Verwendung strukturierter Ausgaben gewinnen.

So sah die strukturierte Ausgabe vor der Pydantic-Integration aus:

from openai import OpenAI
import json

consumer = OpenAI(api_key="your_api_key")

# outline schema as a uncooked dictionary
instruments = (
    {
        "kind": "perform",
        "perform": {
            "title": "extract_person_info",
            "strict": True,
            "parameters": {
                "kind": "object",
                "properties": {
                    "title": {"kind": "string"},
                    "age": {"kind": "integer"},
                    "metropolis": {"kind": "string"}
                },
                "required": ("title", "age", "metropolis"),
                "additionalProperties": False
            }
        }
    }
)

response = consumer.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    tool_choice={"kind": "perform", "perform": {"title": "extract_person_info"}},
    messages=(
        {"position": "consumer", "content material": "Extract data from: 'Maria is 32 years outdated and lives in Athens.'"}
    )
)

# parse manually — we get again a plain dictionary
end result = json.hundreds(response.decisions(0).message.tool_calls(0).perform.arguments)
print(end result("title"))   # "Maria" — however what if the secret is lacking? KeyError.
print(end result("age"))    # is perhaps "32" as a substitute of 32 — kind not assured

Und hier ist das Gleiche mit Pydantic:

from openai import OpenAI
from pydantic import BaseModel

consumer = OpenAI(api_key="your_api_key")

class PersonInfo(BaseModel):
    title: str
    age: int
    metropolis: str

response = consumer.beta.chat.completions.parse(
    mannequin="gpt-4o-mini",
    messages=(
        {"position": "consumer", "content material": "Extract data from: 'Maria is 32 years outdated and lives in Athens.'"}
    ),
    response_format=PersonInfo
)

# we get again a correct Python object, absolutely typed and validated
end result = response.decisions(0).message.parsed
print(end result.title)   # "Maria" — at all times a string
print(end result.age)    # 32 — at all times an integer, by no means a string
print(end result.metropolis)   # "Athens" — at all times a string

Offensichtlich ist die Pydantic-Model kürzer, lesbarer und sicherer. Beachten Sie, wie wir unser Pydantic-Modell an übergeben response_formatund das OpenAI SDK, das die Generierung des JSON-Schemas übernimmt, führt lediglich den API-Aufruf durch strict: Trueund analysiert die Antwort wieder in eine richtige Antwort PersonInfo Objekt. Auf diese Weise erhalten wir Zugriff auf Felder mit Typsicherheit, Validierung und Punktnotation.

Beachten Sie darüber hinaus auch die .parse() Methode, statt der üblichen .create(). Das liegt daran .parse() ist eine Methode im OpenAI SDK, die speziell für die Arbeit mit Pydantic-Modellen entwickelt wurde und die gesamte strukturierte Ausgabepipeline durchgängig verarbeitet.

Aufbau mit Pydantic

1. verschachtelte Modelle und Hear

Einer der Bereiche, in denen Pydantic wirklich glänzt, sind verschachtelte Datenstrukturen. Das Schreiben eines rohen JSON-Schemas für verschachtelte Objekte ist mühsam, aber bei Verwendung von Pydantic werden nur Python-Klassen definiert:

from pydantic import BaseModel
from typing import Checklist

class Handle(BaseModel):
    road: str
    metropolis: str
    nation: str

class ContactInfo(BaseModel):
    title: str
    electronic mail: str
    handle: Handle
    phone_numbers: Checklist(str)

response = consumer.beta.chat.completions.parse(
    mannequin="gpt-4o-mini",
    messages=(
        {
            "position": "consumer",
            "content material": """Extract contact data from:
            'Maria Mouschoutzi, (electronic mail protected), 
            Ermou 15, Athens, Greece. 
            Telephone: +30 210 1234567, +30 697 8901234'"""
        }
    ),
    response_format=ContactInfo
)

contact = response.decisions(0).message.parsed
print(contact.title)                 # "Maria Mouschoutzi"
print(contact.handle.metropolis)        # "Athens"
print(contact.phone_numbers(0))    # "+30 210 1234567"

Der Handle Das Modell ist darin verschachtelt ContactInfo Natürlich übernimmt Pydantic die vollständige Validierung der verschachtelten Struktur. Wir können dann auf Felder mit sauberer Punktnotation zugreifen, wie zum Beispiel: contact.handle.metropolis statt end result("handle")("metropolis")was erhöhen kann KeyError wenn ein Zwischenschlüssel fehlt. Eine der Aufgaben, bei denen Pydantic wirklich praktisch ist, ist die Notwendigkeit verschachtelter Datenstrukturen.

2. Validierung mit Pydantic-Feld

Eine weitere Aufgabe, bei der Pydantic sehr nützlich ist, ist die Validierung der zurückgegebenen Daten. Diese Validierung umfasst die Prüfung von Datentypen, geht aber auch darüber hinaus, da Pydantic auch die Durchsetzung klarer Anweisungen zum tatsächlichen Inhalt der zurückgegebenen Werte ermöglicht. Genauer gesagt können wir mit explizite Validierungseinschränkungen hinzufügen Subjectund gibt dem Modell Anweisungen darüber, welche Werte akzeptabel sind und welche nicht.

Nehmen wir zum Beispiel an, wir haben ein Setup, das Daten zu Produktbewertungen zurückgibt:

from pydantic import BaseModel, Subject
from typing import Elective

class ProductReview(BaseModel):
    product_name: str = Subject(description="The title of the product being reviewed")
    score: int = Subject(ge=1, le=5, description="Score from 1 to five stars")
    sentiment: str = Subject(description="Considered one of: optimistic, impartial, detrimental")
    abstract: str = Subject(max_length=200, description="A quick abstract of the assessment")
    verified_purchase: Elective(bool) = Subject(default=None, description="Whether or not it is a verified buy")

response = consumer.beta.chat.completions.parse(
    mannequin="gpt-4o-mini",
    messages=(
        {
            "position": "consumer",
            "content material": """Extract a structured assessment from:
            'Completely love this espresso machine! 
            Makes good espresso each time. 
            5 stars, would suggest to anybody.'"""
        }
    ),
    response_format=ProductReview
)

assessment = response.decisions(0).message.parsed
print(assessment.product_name)   # "espresso machine"
print(assessment.score)         # 5
print(assessment.sentiment)      # "optimistic"
print(assessment.abstract)        # "Makes good espresso each time."

Insbesondere die ge=1, le=5 auf der score Das Feld teilt dem Modell mit, dass gültige Bewertungen zwischen 1 und 5 liegen max_length=200 auf der abstract stellt sicher, dass wir nie eine Antwort erhalten, die länger als 200 Zeichen ist.

Darüber hinaus ist die description Felder fungieren als Anweisungen für das Modell und helfen ihm dabei, genau zu verstehen, was jedes Feld enthalten soll. Dies ist im Wesentlichen das Äquivalent von description Felder, die wir manuell in Funktionsaufrufschemata geschrieben haben, um dem Modell zu zeigen, was in die einzelnen Felder eingefügt werden soll.

3. Ablehnungen

Hervorzuheben ist auch die Verwendung .parse()verarbeitet das OpenAI SDK auch Modellablehnungen elegant. Genauer gesagt, für den Fall, dass das Mannequin sich weigert, einer Anfrage nachzukommen (z. B. weil der Inhalt gegen die Richtlinien des Fashions verstößt), wird die parsed Feld wird sein None und die refusal Das Feld enthält den Grund. Dies ermöglicht es uns, auch im Falle einer Ablehnung ein strukturiertes Ergebnis zu erhalten und den Anwendungsbenutzer zumindest über den Grund für die Ablehnung seiner Anfrage zu informieren. Dies ist von besonderer Bedeutung für KI-gestützte Apps, die in der Produktion laufen, wo wir nicht wirklich vorhersagen können, welche seltsamen Wünsche der Benutzer möglicherweise haben wird.

So würde sich additionally eine Modellverweigerung bei Pydantic auswirken:

response = consumer.beta.chat.completions.parse(
    mannequin="gpt-4o-mini",
    messages=({"position": "consumer", "content material": "Extract data from the job posting above."}),
    response_format=JobPosting
)

message = response.decisions(0).message

if message.refusal:
    print(f"Mannequin refused: {message.refusal}")
else:
    job = message.parsed
    print(f"Extracted: {job.job_title} at {job.company_name}")

Ein Beispiel aus der Praxis: Extraktion von Dokumentinformationen

Lassen Sie uns alles anhand eines realistischeren Beispiels zusammenfassen. Stellen Sie sich vor, wir bauen eine Pipeline auf, die Stellenausschreibungen verarbeitet und daraus strukturierte Informationen extrahiert. Dies ist genau die Artwork von Aufgabe, bei der strukturierte Ausgaben glänzen: unstrukturierte Eingaben, klar definierte Ausgabeschemata und ein nachgelagertes System, das das Ergebnis in eine Datenbank einfügen muss.

from pydantic import BaseModel, Subject
from typing import Checklist, Elective
from openai import OpenAI

consumer = OpenAI(api_key="your_api_key")

class SalaryRange(BaseModel):
    min_salary: Elective(int) = Subject(default=None, description="Minimal wage in USD per yr")
    max_salary: Elective(int) = Subject(default=None, description="Most wage in USD per yr")
    forex: str = Subject(default="USD", description="Foreign money code")

class JobPosting(BaseModel):
    job_title: str = Subject(description="The job title or position title")
    company_name: str = Subject(description="The title of the hiring firm")
    location: str = Subject(description="Job location, e.g. 'Athens, Greece' or 'Distant'")
    employment_type: str = Subject(description="Considered one of: full-time, part-time, contract, freelance")
    required_skills: Checklist(str) = Subject(description="Checklist of required technical expertise")
    years_of_experience: Elective(int) = Subject(default=None, description="Minimal years of expertise required")
    wage: Elective(SalaryRange) = Subject(default=None, description="Wage vary if talked about")
    remote_friendly: bool = Subject(description="Whether or not distant work is allowed")

job_post_text = """
Senior Python Engineer at pialgorithms (Athens, Greece / Distant)

We're searching for an skilled Python developer to hitch our AI group.
You'll work on our doc administration platform, constructing clever 
search and extraction options utilizing LLMs and RAG pipelines.

Necessities:
- 5+ years of Python expertise
- Sturdy information of FastAPI, LangChain, and vector databases
- Expertise with OpenAI API and Pydantic
- Familiarity with Docker and cloud deployment (AWS/GCP)

Wage: €60,000 - €85,000 per yr
Full-time place. Distant-friendly.
"""

response = consumer.beta.chat.completions.parse(
    mannequin="gpt-4o-mini",
    messages=(
        {
            "position": "system",
            "content material": "You're an knowledgeable at extracting structured data from job postings."
        },
        {
            "position": "consumer",
            "content material": f"Extract all related data from this job posting:nn{job_post_text}"
        }
    ),
    response_format=JobPosting
)

job = response.decisions(0).message.parsed

print(f"Title: {job.job_title}")
print(f"Firm: {job.company_name}")
print(f"Location: {job.location}")
print(f"Distant: {job.remote_friendly}")
print(f"Expertise: {', '.be a part of(job.required_skills)}")
print(f"Expertise: {job.years_of_experience} years")
if job.wage:
    print(f"Wage: {job.wage.min_salary} - {job.wage.max_salary} {job.wage.forex}")

Und die Ausgabe sieht in etwa so aus:

Title: Senior Python Engineer
Firm: pialgorithms
Location: Athens, Greece / Distant
Distant: True
Expertise: Python, FastAPI, LangChain, vector databases, OpenAI API, Pydantic, Docker, AWS, GCP
Expertise: 5 years
Wage: 60000 - 85000 EUR

Dies ist ein produktionsbereiter Extraktionscode. Das Verschachtelte SalaryRange Das Modell verarbeitet die optionalen Gehaltsinformationen sauber. Elective Felder sind standardmäßig auf None wenn Informationen fehlen, und jedes Feld in der Antwort wird automatisch eingegeben und validiert. Das Ergebnis kann ohne zusätzliche Verarbeitung direkt in eine Datenbank eingefügt oder an den nächsten Schritt in einer Pipeline übergeben werden.

In meinen Gedanken

Was mich an der Kombination aus Pydantic und OpenAI am meisten erfreut, ist, wie intestine sie mit der Denkweise eines Python-Entwicklers übereinstimmt. Es definiert Datenstrukturen als Klassen, verwendet Typhinweise und erkennt Typfehler frühzeitig und deutlich. All dies sind traditionell die unvorhersehbarsten Teile jeder KI-Anwendung, vor allem weil wir all dies manuell auf der Python-Seite der KI-App erledigen mussten. Pydantic fungiert als bessere und robustere Verbindung zwischen dem KI-Modell und dem Relaxation unseres Python-Codes.

Danke fürs Lesen!

Wenn du es bis hierher geschafft hast, Vielleicht finden Sie Pialgorithmen nützlich: eine von uns entwickelte Plattform, die Groups dabei hilft, organisatorisches Wissen sicher an einem Ort zu verwalten.

Hat Ihnen dieser Beitrag gefallen? Begleiten Sie mich auf Unterstapel und LinkedIn

Alle Bilder vom Autor, sofern nicht anders angegeben.

# Einführung

Wenn man normalerweise nach einem LLM fragt – Abkürzung für „Großes Sprachmodell„ — für ein ordentliches, strukturierte Ausgabe Wie zum Beispiel bei JSON-Objekten ist eine Mischung aus sorgfältiger, schneller Erstellung und einer „Prise“ Glück erforderlich. Andernfalls kann es schwierig sein, das Modell dazu zu bringen, die erwartete perfekt strukturierte Ausgabe zu erhalten. Zumindest struggle es so, bis ein Roman erschien Open-Supply-Bibliothek kam auf den Plan: Umrisse.

Diese Bibliothek soll typische Probleme verhindern, die bei LLMs in diesen spezifischen ausgabeorientierten Anwendungsfällen auftreten, wie z. B. Halluzinationen. Genauer gesagt führt es ein gewisses Maß an deterministischer Sicherheit in den Ausgabegenerierungsprozess ein.

Lassen Sie uns herausfinden, was outlines Dies ermöglicht uns dieser anschauliche Artikel, in dem wir einige praktische Beispiele in Python zeigen!

# Anwendungsfall 1: A number of-Alternative-Klassifizierung für die Stimmungsanalyse

Bevor Sie sich vollständig mit dem ersten Anwendungsfall befassen, fragen Sie sich vielleicht. Wie funktioniert outlines funktioniert und wie garantiert es die Korrektheit in strukturierten Modellausgaben? Auf der Inferenzebene maskiert es „syntaktisch illegale“ Token während der Generierung, anstatt zu versuchen, fehlerhaften Textual content nach der Generierung zu korrigieren. Dies macht es praktisch unmöglich, die Regeln zu brechen, die dem spezifischen gewünschten Ausgabeformat zugrunde liegen.

Sehen wir uns ein erstes Beispiel an, in dem wir eine Analysepipeline für Kundensupporttickets aufbauen, und wir wollen genau eine Possibility aus einer begrenzten, genehmigten Liste möglicher Optionen. Das ist so ziemlich ein Klassifizierungsproblem, und generate.selection() ist die Funktion, die uns dabei hilft, es nachzuahmen, indem sie das vorliegende Modell dazu zwingt, eines der vordefinierten Literale oder Klassen auszuwählen.

Aber zuerst installieren wir es neben dem transformers So laden Sie vorab trainierte LLMs:

pip set up outlines(transformers)

Der folgende Code verwendet outlines.from_transformers() um ein vorab trainiertes Modell zu laden, das von den automatischen Klassen von Hugging Face für ein Modell und den zugehörigen Tokenizer unterstützt wird. Aber das Tüpfelchen auf dem i ist: Beide sind in einem verpackt outlines Objekt, das später dabei hilft, dem Modell mitzuteilen, was genau es erhalten soll. In der Inferenzphase übergeben wir nicht nur die Benutzeraufforderung, eine Bewertung zu klassifizieren, sondern auch eine Literal Objekt, das die Ausgabebeschränkungen enthält, auf die das Modell beschränken soll:

import outlines
from transformers import AutoTokenizer, AutoModelForCausalLM
from typing import Literal

# 1. Loading the backend utilizing commonplace Transformer-based fashions
model_name = "microsoft/Phi-3-mini-4k-instruct"

# We use outlines to load the mannequin with its from_transformers() perform
mannequin = outlines.from_transformers(
    AutoModelForCausalLM.from_pretrained(model_name),
    AutoTokenizer.from_pretrained(model_name)
)

# 2. Calling the mannequin straight, passing our authorised strings as sort constraints
sentiment = mannequin(
    "Classify the sentiment of this buyer evaluate: 'I have been ready two weeks for my supply and it is nonetheless lacking.'",
    Literal("Optimistic", "Adverse", "Impartial")
)

print(sentiment)

Ausgabe:

Ein Wort der Warnung an dieser Stelle: Obwohl das von uns definierte Literal Teil des integrierten Typisierungsmoduls von Python ist und nicht outlinesübernimmt unsere sofort einsatzbereite Bibliothek hier immer noch die Modellsteuerung: Sowohl das Modell als auch der Tokenizer werden in ein Objekt eingebunden, das Normal-Python-Typen erzwingt, wodurch unter der Haube eine Finite-State-Maschine entsteht, die die Ausgabe nur auf die bereitgestellten Optionen beschränkt.

# Anwendungsfall 2: JSON-Objektgenerierung

In diesem Beispiel wird zunächst ein Pydantic-Objekt definiert, das die gewünschte Struktur für ein JSON-Objekt definiert, das eine fiktive Figur mit Namen, Beschreibung und Alter beschreibt. Es verwendet dann unsere zuvor verpackte outlines Modell, das das Zeichenobjekt übergibt, um sicherzustellen, dass die generierte Ausgabe strikt dieser Struktur für das angeforderte JSON-Objekt folgt:

from pydantic import BaseModel

# 1. Outline a Pydantic mannequin for the specified JSON construction
class Character(BaseModel):
    title: str
    description: str
    age: int

# 2. Utilizing the outlines-wrapped mannequin to generate a JSON output conforming to the Pydantic mannequin
json_output = mannequin(
    "Generate a JSON object describing a fictional character named 'Anya'.",
    Character,
    max_new_tokens=200
)

print(json_output)

Ausgabe:

{ "title": "Anya", "description": "Anya is a younger, adventurous girl with a ardour for exploring new locations and assembly new folks. She has lengthy, curly hair and shiny inexperienced eyes that sparkle with curiosity. Anya is at all times desperate to be taught and likes to share her data with others. She is kind-hearted and at all times prepared to lend a serving to hand to these in want. Anya's favourite hobbies embody mountaineering, studying, and taking part in the guitar. She is a free spirit who values freedom and independence above all else." ,"age": 25 }

# Anwendungsfall 3: Reine JSON-Generierung für REST-APIs

Dieses dritte Beispiel, ebenfalls JSON-bezogen, ähnelt dem vorherigen, steht jedoch in einem etwas anderen Kontext. Stellen Sie sich vor, Sie erstellen eine API, die eine genau definierte JSON-Nutzlast zum Aktualisieren einer Datenbank erfordert. Die Aufforderung an einen Normal-LLM, diese Ausgabe zu erhalten, führt häufig zu lästigen, nachgestellten Zeichen wie Kommas, die einen JSON-Parser wahrscheinlich zum Absturz bringen.

Mit Umrissen definieren wir unser JSON-Nutzlastschema noch einmal mit einem Pydantic-basierten benutzerdefinierten Klassenobjekt.

from pydantic import BaseModel
from typing import Literal
import json

class ServerHealth(BaseModel):
    service_name: str
    uptime_seconds: int
    standing: Literal("OK", "DEGRADED", "DOWN")

# 1. Outlines ought to produce a uncooked string assured to be legitimate JSON
raw_json_string = mannequin(
    "Report the present standing of the primary Auth database.",
    ServerHealth,
    max_new_tokens=50
)

print(sort(raw_json_string))  # It will simply print: 

# 2. Fairly-printing
parsed_json = json.hundreds(raw_json_string)
print(json.dumps(parsed_json, indent=2))

Ausgabe:

{
  "service_name": "auth_db_status",
  "uptime_seconds": 1623456789,
  "standing": "OK"
}

# Schlussbemerkungen

Da LLMs darauf trainiert sind, Chat-Liebhaber zu sein, die in der Lage sind, die Syntax zu brechen oder zu halluzinieren, um in ihren Gesprächen mit uns „wie Menschen zu klingen“, kann es ein wenig mühsam sein, sie dazu zu bringen, zuverlässige, strukturierte Ausgaben wie saubere JSON-Objekte zu erzeugen. Beschreibt eine neue Open-Supply-Bibliothek, die deterministische Sicherheit in den Ausgabegenerierungsprozess von LLMs einführt, um eine bessere und zuverlässigere Generierung strukturierter Ausgaben zu ermöglichen. Dieser Artikel zeigte drei einfache, aber nützliche Anwendungsfälle für Anfänger mit diesem interessanten Device.

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.

Wir haben viel über beliebte Techniken zur Optimierung der Leistung und Kosten von KI-Anwendungen gesprochen, z Antwort-Streaming oder sofortiges Caching. Heute möchte ich über etwas anderes, aber ebenso Wichtiges für die Entwicklung echter KI-Apps sprechen. Das heißt, strukturierte, maschinenlesbare Ausgaben.

Bisher haben wir uns in den meisten Beispielen, die ich geteilt habe, mit Freitextantworten eines KI-Modells befasst. Der Benutzer stellt eine Frage, das Modell antwortet in natürlicher Sprache und wir zeigen dem Benutzer diese Antwort einfach auf irgendeine Weise an. Ziemlich einfach und unkompliziert. Aber was passiert, wenn das Modell Daten in einem bestimmten Format (z. B. einem JSON-Objekt) zurückgeben muss, damit wir sie später programmgesteuert weiterverarbeiten können? Was wäre, wenn wir das Modell benötigen, um bestimmte Felder aus einem Textual content oder Bild zu extrahieren, einen Datenbankeintrag zu füllen oder basierend auf seiner Antwort eine Folgeaktion auszulösen? In solchen Fällen ist es nicht sehr praktisch, eine Textwand wiederherzustellen.

Glücklicherweise gibt es für dieses Downside mehrere Lösungen. Es gibt zwei Hauptansätze, um strukturierte, maschinenlesbare Ausgaben von einem LLM zu erhalten: JSON-Modus Und Funktionsaufruf (auch Werkzeuggebrauch genannt). Diese beiden werden oft miteinander verwechselt (was zu erwarten ist, da es sich bei beiden um strukturierte Ausgaben handelt), aber sie dienen ganz unterschiedlichen Zwecken. Darüber hinaus hat OpenAI eine strengere Variante des Funktionsaufrufs namens „Perform Calling“ eingeführt Strukturierte Ausgabenwas die Schemadurchsetzung, wie wir sehen werden, noch einen Schritt weiter bringt. In diesem Beitrag werfen wir einen genaueren Blick auf alle drei, verstehen, wie sie unter der Haube funktionieren, und finden heraus, wann sie jeweils zu verwenden sind.

Additionally schauen wir mal rein!

1. Was ist der JSON-Modus?

JSON-Modus ist der einfachere Ansatz, um maschinenlesbare Ausgaben eines LLM zu erzielen. Es handelt sich im Wesentlichen um einen Parameter, den Sie in einer API-Anfrage festlegen können, um das Modell anzuweisen stets Gibt ein gültiges JSON-Objekt zurück. Und das ist wirklich alles! Diese Einfachheit hat jedoch ihren Preis, da es keine Garantien für die Struktur oder das Schema des JSON gibt (denken Sie daran, dass wir kein Schema, keine Feldnamen, keine Typen oder ähnliches definiert haben), sondern lediglich dafür, dass es sich um ein gültiges, analysierbares JSON handelt.

Wenn wir beispielsweise die OpenAI-API in Python verwenden, können wir den JSON-Modus aktivieren, indem wir den Parameter hinzufügen response_format={"sort": "json_object"} zu unserem Aufruf zum Mannequin. Genauer gesagt würde es etwa so aussehen:

from openai import OpenAI

shopper = OpenAI(api_key="your_api_key")

response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    response_format={"sort": "json_object"},
    messages=(
        {
            "function": "system",
            "content material": "You're a useful assistant. All the time reply in JSON format."
        },
        {
            "function": "person",
            "content material": "Extract the identify, age, and metropolis from this textual content: 'Maria is 32 years previous and lives in Athens.'"
        }
    )
)

print(response.decisions(0).message.content material)

Und die Antwort würde in etwa so aussehen:

{
  "identify": "Maria",
  "age": 32,
  "metropolis": "Athens"
}

Und voilà! Mit nur einer einfachen Parameteränderung erhalten wir jedes Mal ein gültiges JSON zurück. Kein String-Parsing oder seltsame Regex-Hacks erforderlich.

Allerdings gibt es einen Haken. Der JSON-Modus garantiert, dass die Ausgabe erfolgt gültiges JSONaber das tut es nicht eine bestimmte Struktur garantieren. Wenn wir dasselbe Beispiel mehrmals ausführen, erhalten wir möglicherweise jedes Mal leicht unterschiedliche Feldnamen oder eine leicht unterschiedliche Struktur. Beispielsweise könnte ein Lauf zurückkehren "identify" und noch eins "full_name". Das ist ein Downside, wenn wir versuchen, bestimmte Felder zuverlässig programmgesteuert zu extrahieren.

Eine andere Sache ist, dass sie jenseits der Einstellung liegt response_format={"sort": "json_object"}empfiehlt es sich, das Modell auch immer explizit anzuweisen, in JSON in der Systemeingabeaufforderung zu antworten. Beachten Sie, dass wir im obigen Beispiel auch hinzugefügt haben „Immer im JSON-Format antworten“ in der Systemaufforderung. Ohne dies gibt das Modell möglicherweise manchmal, aber nicht immer, einen gültigen JSON-Code zurück, da sein Verhalten möglicherweise unvorhersehbar wird.

2. Was ist Funktionsaufruf?

Funktionsaufruf (oder Werkzeugverwendung) ist ein fortgeschrittenerer Ansatz, um strukturierte, maschinenlesbare Ausgaben von einem LLM zu erhalten. Anstatt das Modell einfach aufzufordern, seine Antwort als JSON zu formatieren, definieren wir eine bestimmte Schema. Das heißt, wir definieren explizit eine formale Beschreibung der Struktur, der die Ausgabe folgen soll, und auf diese Weise ist das Modell stärker darauf beschränkt, Daten zurückzugeben, die genau diesem Schema entsprechen. Mit anderen Worten: Beim Funktionsaufruf definieren wir im Voraus, welche Felder wir erwarten, welche Typen diese Felder haben sollten, welche erforderlich sind und welche nicht und so weiter.

So würde das gleiche Extraktionsbeispiel mit Funktionsaufrufen aussehen:

from openai import OpenAI
import json

shopper = OpenAI(api_key="your_api_key")

# outline the schema of the output we anticipate
instruments = (
    {
        "sort": "operate",
        "operate": {
            "identify": "extract_person_info",
            "description": "Extract private data from a textual content",
            "parameters": {
                "sort": "object",
                "properties": {
                    "identify": {
                        "sort": "string",
                        "description": "The complete identify of the particular person"
                    },
                    "age": {
                        "sort": "integer",
                        "description": "The age of the particular person"
                    },
                    "metropolis": {
                        "sort": "string",
                        "description": "The town the particular person lives in"
                    }
                },
                "required": ("identify", "age", "metropolis")
            }
        }
    }
)

response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    tool_choice={"sort": "operate", "operate": {"identify": "extract_person_info"}},
    messages=(
        {
            "function": "person",
            "content material": "Extract the identify, age, and metropolis from this textual content: 'Maria is 32 years previous and lives in Athens.'"
        }
    )
)

# parse the structured output
tool_call = response.decisions(0).message.tool_calls(0)
end result = json.masses(tool_call.operate.arguments)
print(end result)

Und die Ausgabe würde so aussehen:

{
  "identify": "Maria",
  "age": 32,
  "metropolis": "Athens"
}

Die Ausgabe für dieses Beispiel mit Funktionsaufrufen ist identisch mit der, die wir im JSON-Modus erhalten haben. Der Hauptunterschied besteht jedoch darin, dass die Ausgabe im Gegensatz zum JSON-Modus beim Funktionsaufruf konsistent ist. es wird stets Folgen Sie dem genau definierten Schema mit konsistenten Feldnamen, Typen und allen anderen Attributen, die wir darauf definieren.

DataCream ist ein Publication mit Geschichten und Tutorials zu KI, Daten und Technologie. Wenn Sie sich für diese Themen interessieren, Abonnieren Sie hier!

Bonus: Etwas mehr zum Funktionsaufruf

Bevor wir zu strukturierten Ausgaben übergehen, lohnt es sich, eine Pause einzulegen und die ursprüngliche Motivation und Verwendung des Funktionsaufrufs genauer zu erläutern, der weit über das bloße Erhalten strukturierter Ausgaben hinausgeht. Im Wesentlichen ist das Konzept des Funktionsaufrufs die Grundlage für Agenten-KI-Workflows. Genauer gesagt ist es in einem Agenten-Setup das LLM nicht nur antworten auf die Frage eines Benutzers, sondern es ist so entscheiden Welche Aktion als Nächstes ausgeführt werden soll, basierend auf der Eingabe des Benutzers.

Stellen wir uns zum Beispiel einen Kundendienstassistenten vor, der je nach den Fragen des Benutzers entweder eine Bestellung nachschlagen, eine Rückerstattung veranlassen oder an einen menschlichen Agenten eskalieren kann. Mit Funktionsaufrufen können wir alle drei dieser Kandidatenaktionen als „Werkzeuge“ (Funktionen) definieren, und die Ausgabe des Modells definiert basierend auf der Eingabe, welche aufgerufen werden soll und mit welchen Argumenten.

instruments = (
    {
        "sort": "operate",
        "operate": {
            "identify": "lookup_order",
            "description": "Lookup the standing of a buyer order",
            "parameters": {
                "sort": "object",
                "properties": {
                    "order_id": {"sort": "string", "description": "The order ID"}
                },
                "required": ("order_id")
            }
        }
    },
    {
        "sort": "operate",
        "operate": {
            "identify": "issue_refund",
            "description": "Concern a refund for a buyer order",
            "parameters": {
                "sort": "object",
                "properties": {
                    "order_id": {"sort": "string"},
                    "purpose": {"sort": "string"}
                },
                "required": ("order_id", "purpose")
            }
        }
    }
)

response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    messages=(
        {"function": "person", "content material": "I need a refund for order #12345, it arrived damaged."}
    )
)

tool_call = response.decisions(0).message.tool_calls(0)
print(tool_call.operate.identify)       # "issue_refund"
print(tool_call.operate.arguments)  # '{"order_id": "12345", "purpose": "arrived damaged"}'

Das API-Antwortobjekt sieht additionally etwa so aus:

ChatCompletionMessage(
    content material=None,
    function='assistant',
    tool_calls=(
        ChatCompletionMessageToolCall(
            id='call_abc123',
            sort='operate',
            operate=Perform(
                identify='issue_refund',
                arguments='{"order_id": "12345", "purpose": "arrived damaged"}'
            )
        )
    )
)

Und die print-Anweisungen würden hypothetisch Folgendes ausgeben:

issue_refund
{"order_id": "12345", "purpose": "arrived damaged"}

Additionally, was passiert hier? Das Modell gibt a zurück tool_calls Objekt anstelle einer regulären Textantwort (sehen Sie sich an, wiecontent material Ist None). Im Inneren tool_calls Objekt können wir sehen, dass sich das Modell für den Aufruf entschieden hat issue_refund (nicht lookup_order) und füllte die Argumente selbstständig basierend auf den Aussagen des Benutzers aus. Anschließend analysieren wir diese Argumente und führen die eigentliche Rückerstattungslogik in unserem System aus.

Beachten Sie, dass das Modell nicht nur die angeforderten Daten zurückgegeben hat, sondern vielmehr entschieden Welche der Kandidatenaktionen am besten geeignet ist, trägt dann die entsprechenden Argumente in die Antwort ein. Auf diese Weise können wir diese Argumente dann nutzen und tatsächlich die entsprechende Aktion in unserem System ausführen. Darin liegt die wahre Stärke des Funktionsaufrufs und deshalb ist er eine so grundlegende Komponente in Agenten-KI-Anwendungen.

Aber kommen wir jetzt zurück zu den maschinenlesbaren Ausgaben und werden in einem anderen Beitrag mehr über agentische KI-Workflows und Funktionsaufrufe sprechen.

3. Was ist mit strukturierten Ausgaben?

Eine strengere Variante des Funktionsaufrufs ist Strukturierte Ausgaben. Auch wenn der Funktionsaufruf das Modell dazu anleitet, eine Ausgabe nach einem definierten Schema bereitzustellen, ist dies nicht der Fall Wirklich stark eingeschränkt. In der Praxis bedeutet dies, dass es dennoch zu einigen Abweichungen von diesem definierten Schema kommen kann. Solche Abweichungen können sein:

• Ein als erforderlich markiertes Feld, das tatsächlich weggelassen wird, wenn das Modell Schwierigkeiten hat, seinen Wert herauszufinden
• Zusätzliche Felder, die in unserem Schema nicht definiert sind, werden hinzugefügt
• Ein Feld definiert als integer kommt als String zurück "32" anstatt 32

…und so weiter.

Dies liegt daran, dass beim Funktionsaufruf das Modell vorhanden ist versuchen dem Schema zu folgen, aber dies ist immer noch eine Finest-Effort-Era. Wie bei jeder LLM-Ausgabe besteht die Ausgabe hier immer noch im Wesentlichen aus Token, die einzeln vorhergesagt werden, wobei das Schema nur ein starker Hinweis ist. Es besteht immer noch eine gute Likelihood, dass diese Token-für-Token-Generierung irgendwo auf der Route entgleist und Ausgaben erzeugt, die vom definierten Schema abweichen.

Strukturierte Ausgaben hingegen gehen beim Funktionsaufruf noch einen Schritt weiter, indem sie garantieren, dass jedes Feld im definierten Schema immer genau wie definiert in der Ausgabe erscheint, ohne Überraschungen, ohne fehlende oder zusätzliche Felder. Das Hauptunterscheidungsmerkmal ist, dass OpenAI verwendet wird eingeschränkte Dekodierung hinter den Kulissen. Dies bedeutet, dass das Modell bei jedem Token-Schritt nur Token generieren darf, die die Ausgabe gemäß dem Schema gültig halten. Mit anderen Worten: Das Schema wird auf Generierungsebene erzwungen, anstatt nur über die Systemeingabeaufforderung angefordert zu werden.

Die strukturierten Ausgänge von OpenAI können durch einfache Einstellung aktiviert werden strict: true in der Funktionsdefinition:

instruments = (
    {
        "sort": "operate",
        "operate": {
            "identify": "extract_person_info",
            "strict": True,  # allows Structured Outputs
            "parameters": {
                "sort": "object",
                "properties": {
                    "identify": {"sort": "string"},
                    "age": {"sort": "integer"},
                    "metropolis": {"sort": "string"}
                },
                "required": ("identify", "age", "metropolis"),
                "additionalProperties": False
            }
        }
    }
)

Aber auch dies hat seinen Preis. Strukturierte Ausgaben sind auf GPT-4o und späteren Modellen verfügbar, wobei ältere Modelle auf den JSON-Modus zurückgreifen. Nicht jede JSON-Struktur wird unterstütztund es kann etwas langsamer sein, da OpenAI die Ergebnisse vorverarbeitet.

Dennoch ist es die strengste und sicherste Methode, ein bestimmtes Schema für die Modellausgaben ohne Spielraum für Abweichungen durchzusetzen. Für Produktionssysteme, bei denen Zuverlässigkeit und Konsistenz wirklich wichtig sind, ist dies im Allgemeinen die sicherste Choice.

Aber ist das nicht alles dasselbe?

Der JSON-Modus, Funktionsaufrufe und strukturierte Ausgaben scheinen möglicherweise dasselbe zu bewirken, da sie alle im Wesentlichen JSON aus dem Modell zurückerhalten. Dennoch unterscheiden sie sich, wie wir bereits gesehen haben, deutlich darin, was sie garantieren und wofür sie konzipiert sind. Insbesondere:

• Durchsetzung des Schemas: Der JSON-Modus gibt ein gültiges JSON zurück, jedoch ohne strukturelle Garantien. Funktionsaufrufe geben einen gültigen JSON-Code zurück, der einem definierten Schema entspricht und bestimmten Feldnamen, Typen und erforderlichen Feldern folgt. Abweichungen sind jedoch weiterhin möglich. Structured Outputs geht noch einen Schritt weiter und erzwingt dieses Schema auf Generierungsebene, wodurch Abweichungen unmöglich werden.
• Anwendungsfall: Der JSON-Modus ist für Fälle gedacht, in denen wir eine maschinenlesbare Antwort benötigen, aber mit einem variablen Format leben können. Funktionsaufrufe wurden in erster Linie für Fälle entwickelt, in denen das Modell eine Aktion auslösen oder Argumente an ein externes Instrument übergeben muss. Dies ist im Wesentlichen der allgemeine Fall maschinenlesbarer Ausgaben. Strukturierte Ausgaben sind Funktionsaufrufe mit einer Zuverlässigkeitsgarantie und eignen sich daher splendid für Produktionspipelines, bei denen wir Konsistenz bei den Ausgaben benötigen.
• Einfache Einrichtung: Der JSON-Modus ist die einfachste einzurichtende Choice. nur eine einzelne Parameteränderung ohne Schemadefinition. Auf der anderen Seite müssen wir für Funktionsaufrufe und strukturierte Ausgaben auch über das JSON-Schema nachdenken und es einrichten.

Allerdings OpenAI selbst empfiehlt, wann immer möglich, immer strukturierte Ausgaben anstelle des JSON-Modus zu verwendenals allgemeine Faustregel.

In meinen Gedanken

Das Erhalten maschinenlesbarer Ausgaben von LLMs und die Wahl des geeigneten Ansatzes dafür kann einen großen Unterschied in der Zuverlässigkeit und Wartbarkeit jeder KI-Anwendung machen. Freitext-Antworten eignen sich hervorragend für Konversationsschnittstellen, aber sobald unser LLM eine Komponente in einem größeren System ist (z. B. Daten weiterleiten, Aktionen auslösen, Datenbanken füllen usw.), sind strukturierte Antworten unerlässlich. JSON-Modus, Funktionsaufrufe und strukturierte Ausgaben können solche Ausgaben bereitstellen, jeweils mit unterschiedlicher Strenge. Wie bei vielen Entscheidungen in der KI-Technik hängt die richtige Wahl davon ab, was Sie bauen und wie viel Variabilität Sie tolerieren können.

Wenn du es bis hierher geschafft hast, Vielleicht finden Sie Pialgorithmen nützlich – eine von uns entwickelte Plattform, die Groups dabei hilft, organisatorisches Wissen sicher an einem Ort zu verwalten.

Hat Ihnen dieser Beitrag gefallen? Begleiten Sie mich Unterstapel und LinkedIn

Alle Bilder vom Autor, sofern nicht anders angegeben.

Aktie

Publish


Aktie

In diesem Artikel lernen Sie die architektonischen Unterschiede zwischen strukturierten Ausgaben und Funktionsaufrufen in modernen Sprachmodellsystemen kennen.

Zu den Themen, die wir behandeln werden, gehören:

• Wie strukturierte Ausgaben und Funktionsaufrufe unter der Haube funktionieren.
• Wann die einzelnen Ansätze in realen maschinellen Lernsystemen verwendet werden sollten.
• Die Kompromisse zwischen Leistung, Kosten und Zuverlässigkeit zwischen beiden.

Strukturierte Ausgaben vs. Funktionsaufrufe: Was sollte Ihr Agent verwenden?
Bild vom Herausgeber

Einführung

Sprachmodelle (LMs) sind im Kern Textual content-In- und Textual content-Out-Systeme. Für einen Menschen, der sich über eine Chat-Schnittstelle mit jemandem unterhält, ist das vollkommen in Ordnung. Aber für Praktiker des maschinellen Lernens, die autonome Agenten und zuverlässige Software program-Pipelines erstellen, ist die Analyse, Weiterleitung und Integration von rohem, unstrukturiertem Textual content in deterministische Systeme ein Albtraum.

Um zuverlässige Agenten zu entwickeln, benötigen wir vorhersehbare, maschinenlesbare Ausgaben und die Fähigkeit, nahtlos mit externen Umgebungen zu interagieren. Um diese Lücke zu schließen, haben moderne LM-API-Anbieter (wie OpenAI, Anthropic und Google Gemini) zwei Hauptmechanismen eingeführt:

1. Strukturierte Ausgaben: Erzwingen einer Antwort des Modells durch genaue Einhaltung eines vordefinierten Schemas (am häufigsten ein JSON-Schema oder ein Python-Pydantic-Modell)
2. Funktionsaufruf (Werkzeugverwendung): Statten Sie das Modell mit einer Bibliothek funktionaler Definitionen aus, die es basierend auf dem Kontext der Eingabeaufforderung dynamisch aufrufen kann

Auf den ersten Blick sehen diese beiden Fähigkeiten sehr ähnlich aus. Beide basieren typischerweise auf der Übergabe von JSON-Schemata an die API unter der Haube, und beide führen dazu, dass das Modell strukturierte Schlüssel-Wert-Paare anstelle von Konversationsprosa ausgibt. Allerdings dienen sie grundsätzlich unterschiedlichen architektonischen Zwecken im Agentendesign.

Beides zu verwechseln, ist eine häufige Gefahr. Die Wahl des falschen Mechanismus für eine Funktion kann zu brüchigen Architekturen, übermäßiger Latenz und unnötig hohen API-Kosten führen. Lassen Sie uns die architektonischen Unterschiede zwischen diesen Methoden aufschlüsseln und einen Entscheidungsrahmen für die Verwendung der einzelnen Methoden bereitstellen.

Die Mechanik auspacken: Wie sie unter der Haube funktioniert

Um zu verstehen, wann diese Funktionen verwendet werden sollten, ist es notwendig zu verstehen, wie sie sich auf mechanischer und API-Ebene unterscheiden.

Mechanik strukturierter Ausgänge

In der Vergangenheit warfare es auf promptes Engineering angewiesen, um ein Modell zur Ausgabe von Roh-JSON zu bringen („Sie sind ein hilfreicher Assistent, der *nur* in JSON spricht…“). Dies warfare fehleranfällig und erforderte umfangreiche Wiederholungslogik und Validierung.

Moderne „strukturierte Ausgaben“ ändern dies grundlegend grammatikbeschränkte Dekodierung. Bibliotheken mögen Umrisseoder native Funktionen wie Strukturierte Ausgaben von OpenAIschränken die Token-Wahrscheinlichkeiten zum Zeitpunkt der Generierung mathematisch ein. Wenn das gewählte Schema vorschreibt, dass das nächste Token ein Anführungszeichen oder ein bestimmter boolescher Wert sein muss, werden die Wahrscheinlichkeiten aller nicht konformen Token ausgeblendet (auf Null gesetzt).

Dabei handelt es sich um eine Single-Flip-Technology, die sich strikt auf die Entwicklung konzentriert bilden. Das Modell antwortet direkt auf die Eingabeaufforderung, sein Vokabular ist jedoch auf die genaue Struktur beschränkt, die Sie definiert haben, mit dem Ziel, eine nahezu 100-prozentige Schemakonformität sicherzustellen.

Funktionsaufrufmechanik

Der Funktionsaufruf hingegen ist stark abhängig von Anleitung zum Tuning. Während des Trainings wird das Modell so abgestimmt, dass es Situationen erkennt, in denen es nicht über die notwendigen Informationen verfügt, um eine Eingabeaufforderung abzuschließen, oder wenn die Eingabeaufforderung es explizit zu einer Aktion auffordert.

Wenn Sie einem Modell eine Liste mit Werkzeugen bereitstellen, sagen Sie ihm: „Bei Bedarf können Sie Ihre Textgenerierung anhalten, ein Werkzeug aus dieser Liste auswählen und die notwendigen Argumente generieren, um es auszuführen.“

Dies ist ein von Natur aus interaktiver Ablauf mit mehreren Runden:

1. Das Modell beschließt, ein Software aufzurufen und gibt den Toolnamen und die Argumente aus.
2. Das Modell pausiert. Der Code selbst kann nicht ausgeführt werden.
3. Ihr Anwendungscode führt die ausgewählte Funktion lokal unter Verwendung der generierten Argumente aus.
4. Ihre Anwendung gibt das Ergebnis der Funktion an das Modell zurück.
5. Das Modell synthetisiert diese neuen Informationen und generiert weiterhin seine endgültige Antwort.

Wann sollten Sie strukturierte Ausgaben wählen?

Strukturierte Ausgaben sollten Ihr Standardansatz sein, wenn das Ziel eine reine Datentransformation, -extraktion oder -standardisierung ist.

Hauptanwendungsfall: Das Modell verfügt über alle notwendigen Informationen im Eingabeaufforderungs- und Kontextfenster; es muss nur umgestaltet werden.

Beispiele für Praktiker:

• Datenextraktion (ETL): Verarbeiten Sie rohen, unstrukturierten Textual content wie ein Kundensupport-Transkript und extrahieren Sie Entitäten &emdash; Namen, Daten, Beschwerdearten und Stimmungswerte &emdash; in ein striktes Datenbankschema.
• Abfragegenerierung: Konvertieren einer chaotischen Benutzeraufforderung in natürlicher Sprache in eine strenge, validierte SQL-Abfrage oder eine GraphQL-Nutzlast. Wenn das Schema fehlerhaft ist, schlägt die Abfrage fehl, sodass eine 100-prozentige Einhaltung erforderlich ist.
• Begründung des internen Agenten: Die „Gedanken“ eines Agenten strukturieren, bevor er handelt. Sie können a durchsetzen Pydantisch Modell, das eine erfordert thought_process Feld, ein assumptions Feld und schließlich a resolution Feld. Dies erzwingt a Gedankenkette Prozess, der von Ihren Backend-Protokollierungssystemen problemlos analysiert werden kann.

Das Urteil: Verwenden Sie strukturierte Ausgaben, wenn die „Aktion“ lediglich in der Formatierung besteht. Da es keine Interaktion der mittleren Technology mit externen Systemen gibt, gewährleistet dieser Ansatz eine hohe Zuverlässigkeit, geringere Latenz und keine Schema-Parsing-Fehler.

Wann sollte man sich für den Funktionsaufruf entscheiden?

Funktionsaufrufe sind der Motor der Agentenautonomie. Wenn strukturierte Ausgaben dies vorschreiben Type der Daten bestimmt der Funktionsaufruf Kontrollfluss der Bewerbung.

Hauptanwendungsfall: Externe Interaktionen, dynamische Entscheidungsfindung und Fälle, in denen das Modell Informationen abrufen muss, über die es derzeit nicht verfügt.

Beispiele für Praktiker:

• Ausführen realer Aktionen: Auslösen externer APIs basierend auf der Konversationsabsicht. Wenn ein Benutzer sagt: „Buche meinen üblichen Flug nach New York“, löst das Modell mithilfe von Funktionsaufrufen die Aktion aus book_flight(vacation spot="JFK") Werkzeug.
• Retrieval-Augmented Technology (RAG): Anstelle einer naiven RAG-Pipeline, die immer eine Vektordatenbank durchsucht, kann ein Agent eine verwenden search_knowledge_base Werkzeug. Das Modell entscheidet dynamisch Was Die zu verwendenden Suchbegriffe werden je nach Kontext ausgewählt oder es wird entschieden, überhaupt nicht zu suchen, wenn die Antwort bereits bekannt ist.
• Dynamische Aufgabenweiterleitung: Bei komplexen Systemen könnte ein Router-Modell Funktionsaufrufe verwenden, um den am besten spezialisierten Subagenten auszuwählen (z. B. Calling). delegate_to_billing_agent gegen delegate_to_tech_support), um eine bestimmte Abfrage zu bearbeiten.

Das Urteil: Wählen Sie den Funktionsaufruf, wenn das Modell mit der Außenwelt interagieren, versteckte Daten abrufen oder Softwarelogik mitten im Gedanken bedingt ausführen muss.

Auswirkungen auf Leistung, Latenz und Kosten

Bei der Bereitstellung von Agenten in der Produktion wirkt sich die architektonische Wahl zwischen diesen beiden Methoden direkt auf die Wirtschaftlichkeit Ihrer Einheit und das Benutzererlebnis aus.

• Token-Verbrauch: Funktionsaufrufe erfordern oft mehrere Roundtrips. Sie senden die Systemaufforderung, das Modell sendet Werkzeugargumente, Sie senden die Werkzeugergebnisse zurück und das Modell sendet schließlich die Antwort. Jeder Schritt wird an das Kontextfenster angehängt und sammelt die Verwendung von Eingabe- und Ausgabe-Tokens. Strukturierte Ausgaben werden normalerweise in einer einzigen, kostengünstigeren Runde gelöst.
• Latenzaufwand: Die mit Funktionsaufrufen verbundenen Roundtrips führen zu einer erheblichen Netzwerk- und Verarbeitungslatenz. Ihre Anwendung muss auf das Modell warten, lokalen Code ausführen und erneut auf das Modell warten. Wenn Ihr primäres Ziel lediglich darin besteht, Daten in ein bestimmtes Format zu bringen, sind strukturierte Ausgaben wesentlich schneller.
• Zuverlässigkeit vs. Wiederholungslogik: Streng strukturierte Ausgaben (über eingeschränkte Dekodierung) bieten nahezu 100 % Schematreue. Sie können der Ausgabeform ohne komplexe Parsing-Blöcke vertrauen. Der Funktionsaufruf ist jedoch statistisch unvorhersehbar. Das Modell könnte ein Argument halluzinieren, das falsche Werkzeug auswählen oder in einer Diagnoseschleife stecken bleiben. Funktionsaufrufe in Produktionsqualität erfordern eine robuste Wiederholungslogik, Fallback-Mechanismen und eine sorgfältige Fehlerbehandlung.

Hybride Ansätze und Finest Practices

In fortschrittlichen Agentenarchitekturen verschwimmt die Grenze zwischen diesen beiden Mechanismen häufig, was zu hybriden Ansätzen führt.

Die Überschneidung:
Es ist erwähnenswert, dass es tatsächlich moderne Funktionsaufrufe gibt verlässt sich auf strukturierten Ausgaben unter der Haube, um sicherzustellen, dass die generierten Argumente mit Ihren Funktionssignaturen übereinstimmen. Umgekehrt können Sie einen Agenten entwerfen, der nur strukturierte Ausgaben verwendet, um ein JSON-Objekt zurückzugeben, das eine Aktion beschreibt, die Ihr deterministisches System ausführen soll nach die Generierung ist abgeschlossen &emdash; Effektive Täuschung der Werkzeugnutzung ohne Multi-Flip-Latenz.

Architekturberatung:

• Das „Controller“-Muster: Verwenden Sie Funktionsaufrufe für den Orchestrator oder „Gehirn“-Agenten. Lassen Sie es frei Instruments aufrufen, um Kontext zu sammeln, Datenbanken abzufragen und APIs auszuführen, bis es überzeugt ist, dass es den erforderlichen Standing erreicht hat.
• Das „Formatter“-Muster: Sobald die Aktion abgeschlossen ist, leiten Sie die Rohergebnisse an ein endgültiges, kostengünstigeres Modell weiter, das nur strukturierte Ergebnisse verwendet. Dies garantiert, dass die endgültige Antwort perfekt Ihren UI-Komponenten oder nachgelagerten REST-API-Erwartungen entspricht.

Zusammenfassung

LM Engineering vollzieht einen raschen Übergang von der Entwicklung von Konversations-Chatbots hin zur Entwicklung zuverlässiger, programmatischer und autonomer Agenten. Der Schlüssel zu diesem Übergang liegt darin, zu verstehen, wie Sie Ihre Modelle einschränken und lenken.

TL;DR

• Verwenden strukturierte Ausgaben diktieren Type der Daten
• Verwenden Funktionsaufruf diktieren Aktionen und Interaktionen

Der Entscheidungsbaum des Praktikers

Gehen Sie beim Erstellen einer neuen Funktion diese kurze dreistufige Checkliste durch:

1. Benötige ich während des Denkens externe Daten oder muss ich eine Aktion ausführen? ⭢ Verwenden Sie Funktionsaufrufe
2. Analysiere, extrahiere oder übersetze ich nur unstrukturierten Kontext in strukturierte Daten? ⭢ Verwenden Sie strukturierte Ausgaben
3. Benötige ich eine absolute, strikte Einhaltung eines komplex verschachtelten Objekts? ⭢ Verwenden Sie strukturierte Ausgaben über eingeschränkte Dekodierung

Letzter Gedanke

Die effektivsten KI-Ingenieure betrachten Funktionsaufrufe als eine leistungsstarke, aber unvorhersehbare Fähigkeit, die sparsam eingesetzt und von einer robusten Fehlerbehandlung begleitet werden sollte. Umgekehrt sollten strukturierte Ergebnisse als zuverlässiger, grundlegender Klebstoff betrachtet werden, der moderne KI-Datenpipelines zusammenhält.

Aktie

Publish


Aktie

Bei der Integration strukturierter Daten in ein RAG-System binden Ingenieure häufig standardmäßig rohes JSON in eine Vektordatenbank ein. Die Realität ist jedoch, dass dieser intuitive Ansatz zu einer dramatisch schlechten Leistung führt. Moderne Einbettungen basieren auf der BERT-Architektur, die im Wesentlichen der Encoder-Teil von a ist Transformatorund werden anhand eines riesigen Textdatensatzes trainiert, mit dem Hauptziel, die semantische Bedeutung zu erfassen. Moderne Einbettungsmodelle können eine unglaubliche Abrufleistung bieten, sie werden jedoch auf eine große Menge unstrukturierter Texte trainiert, wobei der Schwerpunkt auf der semantischen Bedeutung liegt. Auch wenn die Einbettung von JSON wie eine intuitiv einfache und elegante Lösung erscheint, würde die Verwendung eines generischen Einbettungsmodells für JSON-Objekte Ergebnisse liefern, die weit von der Spitzenleistung entfernt sind.

Tiefer Tauchgang

Tokenisierung

Der erste Schritt ist die Tokenisierung, bei der der Textual content in Token aufgeteilt wird, die im Allgemeinen einen generischen Teil des Wortes darstellen. Die modernen Einbettungsmodelle nutzen Byte-Pair-Encoding (BPE) oder WordPiece-Tokenisierungsalgorithmen. Diese Algorithmen sind für natürliche Sprache optimiert und zerlegen Wörter in gemeinsame Unterkomponenten. Wenn ein Tokenizer auf rohes JSON stößt, hat er Probleme mit der hohen Häufigkeit nicht-alphanumerischer Zeichen. Zum Beispiel, "usd": 10, wird nicht als Schlüssel-Wert-Paar betrachtet; Stattdessen ist es fragmentiert:

• Die Zitate ("), Doppelpunkt (:) und Komma (,)
• Token usd Und 10

Dadurch entsteht ein Tief Sign-Rausch-Verhältnis. In der natürlichen Sprache tragen quick alle Wörter zum semantischen „Sign“ bei. Während in JSON (und anderen strukturierten Formaten) ein erheblicher Prozentsatz der Token für strukturelle Syntax „verschwendet“ wird, die keinen semantischen Wert enthält.

Aufmerksamkeitsberechnung

Die Kernkraft von Transformatoren liegt im Aufmerksamkeitsmechanismus. Dadurch kann das Modell die Bedeutung der Token relativ zueinander gewichten.

Im Satz The value is 10 US {dollars} or 9 eurosAufmerksamkeit kann den Wert leicht verknüpfen 10 zum Konzept worth weil diese Beziehungen in den Pre-Coaching-Daten des Modells intestine dargestellt sind und das Modell dieses sprachliche Muster millionenfach gesehen hat. Andererseits im rohen JSON:

"worth": {
  "usd": 10,
  "eur": 9,
 }

Das Modell stößt auf eine strukturelle Syntax, die nicht primär für das „Lesen“ optimiert wurde. Ohne den linguistischen Konnektor kann der resultierende Vektor die wahre Absicht der Daten nicht erfassen, da die Beziehungen zwischen dem Schlüssel und dem Wert durch das Format selbst verdeckt werden.

Mittleres Pooling

Der letzte Schritt beim Generieren einer einzelnen Einbettungsdarstellung des Dokuments ist Imply Pooling. Mathematisch gesehen ist die endgültige Einbettung (E) ist der Schwerpunkt aller Token-Vektoren (e1, e2, e3) im Dokument:

Hier werden die JSON-Tokens zu einer mathematischen Belastung. Wenn 25 % der Token im Dokument strukturelle Markierungen (geschweifte Klammern, Anführungszeichen, Doppelpunkte) sind, wird der endgültige Vektor stark von der „Bedeutung“ der Interpunktion beeinflusst. Dadurch wird der Vektor durch diese Rauschtoken effektiv von seinem wahren semantischen Zentrum im Vektorraum „herausgezogen“. Wenn ein Benutzer eine Abfrage in natürlicher Sprache sendet, vergrößert sich der Abstand zwischen dem „sauberen“ Abfragevektor und dem „verrauschten“ JSON-Vektor, was sich direkt negativ auf die Abrufmetriken auswirkt.

Machen Sie es flach

Nachdem wir nun die JSON-Einschränkungen kennen, müssen wir herausfinden, wie wir sie beheben können. Der allgemeine und einfachste Ansatz besteht darin, JSON zu reduzieren und in natürliche Sprache umzuwandeln.

Betrachten wir das typische Produktobjekt:

{
 "skuId": "123",
 "description": "It is a check product used for demonstration functions",
 "amount": 5,
 "worth": {
  "usd": 10,
  "eur": 9,
 },
 "availableDiscounts": ("1", "2", "3"),
 "giftCardAvailable": "true", 
 "class": "demo product"
 ...
}

Dies ist ein einfaches Objekt mit einigen Attributen wie Beschreibung usw. Wenden wir die Tokenisierung darauf an und sehen, wie es aussieht:

Nun wandeln wir es in Textual content um, um die Arbeit der Einbettungen zu erleichtern. Dazu können wir eine Vorlage definieren und die JSON-Werte darin ersetzen. Diese Vorlage könnte beispielsweise zur Beschreibung des Produkts verwendet werden:

Product with SKU {skuId} belongs to the class "{class}"
Description: {description}
It has a amount of {amount} accessible 
The value is {worth.usd} US {dollars} or {worth.eur} euros  
Obtainable low cost ids embrace {availableDiscounts as comma-separated listing}  
Present playing cards are {giftCardAvailable ? "accessible" : "not accessible"} for this product

Das Endergebnis wird additionally so aussehen:

Product with SKU 123 belongs to the class "demo product"
Description: It is a check product used for demonstration functions
It has a amount of 5 accessible
The value is 10 US {dollars} or 9 euros
Obtainable low cost ids embrace 1, 2, and three
Present playing cards can be found for this product

Und wenden Sie den Tokenizer darauf an:

Es verfügt jetzt nicht nur über 14 % weniger Token, sondern ist auch eine viel klarere Type mit der semantischen Bedeutung und dem erforderlichen Kontext.

Lassen Sie uns die Ergebnisse messen

Hinweis: Der vollständige, reproduzierbare Code für dieses Experiment ist im verfügbar Google Colab-Notizbuch

Versuchen wir nun, die Abrufleistung für beide Optionen zu messen. Wir werden uns auf die Customary-Abrufmetriken wie Recall@okay, Precision@okay und MRR konzentrieren, um es einfach zu halten, und werden ein generisches Einbettungsmodell verwenden (All-MiniLM-L6-v2) und die Amazon ESCI Datensatz mit zufälligen 5.000 Abfragen und 3.809 zugehörigen Produkten.

Der All-MiniLM-L6-v2 ist eine beliebte Wahl, da sie klein ist (22,7 m Parameter), aber schnelle und genaue Ergebnisse liefert, was sie zu einer guten Wahl für dieses Experiment macht.

Für den Datensatz die Model von Amazon ESCI wird speziell verwendet milistu/amazon-esci-data (), das auf Hugging Face verfügbar ist und eine Sammlung von Amazon-Produkten und Suchanfragendaten enthält.

Die für die Textkonvertierung verwendete Reduzierungsfunktion ist:

def flatten_product(product):
  return (
    f"Product {product('product_title')} from model {product('product_brand')}" 
    f" and product id {product('product_id')}" 
    f" and outline {product('product_description')}"
)

Ein Beispiel der JSON-Rohdaten ist:

{
  "product_id": "B07NKPWJMG",
  "title": "RoWood 3D Puzzles for Adults, Wood Mechanical Gear Kits for Teenagers Children Age 14+",
  "description": "<p> <sturdy>Specs</sturdy><br /> Mannequin Quantity: Rowood Treasure field LK502<br /> Common construct time: 5 hours<br /> Complete Items: 123<br /> Mannequin weight: 0.69 kg<br /> Field weight: 0.74 KG<br /> Assembled measurement: 100*124*85 mm<br /> Field measurement: 320*235*39 mm<br /> Certificates: EN71,-1,-2,-3,ASTMF963<br /> Beneficial Age Vary: 14+<br /> <br /> <sturdy>Contents</sturdy><br /> Plywood sheets<br /> Metallic Spring<br /> Illustrated directions<br /> Equipment<br /> <br /> <sturdy>MADE FOR ASSEMBLY</sturdy><br /> -Observe the directions offered within the booklet and meeting 3d puzzle with some thrilling and interesting enjoyable. Fell the pleasure of self creation getting this beautiful picket work like a professional.<br /> <sturdy>GLORIFY YOUR LIVING SPACE</sturdy><br /> -Revive the enigmatic attraction and cheer your events and get-togethers with an expertise that's distinctive and attention-grabbing .<br /> <br />",
  "model": "RoWood",
  "coloration": "Treasure Field"
}

Für die Vektorsuche zwei FAISS Es werden Indizes erstellt: einer für den reduzierten Textual content und einer für den JSON-formatierten Textual content. Beide Indizes sind flach, was bedeutet, dass sie die Entfernungen für jeden der vorhandenen Einträge vergleichen, anstatt einen zu verwenden Ungefährer nächster Nachbar (ANN) Index. Dies ist wichtig, um sicherzustellen, dass die Abrufmetriken nicht durch das ANN beeinflusst werden.

D = 384
index_json = faiss.IndexFlatIP(D)
index_flatten = faiss.IndexFlatIP(D)

Um den Datensatz zu reduzieren, wurde eine zufällige Anzahl von 5.000 Abfragen ausgewählt und alle entsprechenden Produkte eingebettet und den Indizes hinzugefügt. Infolgedessen lauten die gesammelten Metriken wie folgt:

Und die Leistungsänderung der abgeflachten Model ist:

Die Analyse bestätigt, dass die Einbettung strukturierter Rohdaten in den generischen Vektorraum ein suboptimaler Ansatz ist und dass das Hinzufügen eines einfachen Vorverarbeitungsschritts zur Glättung strukturierter Daten durchweg eine erhebliche Verbesserung der Abrufmetriken liefert (Erhöhung von Recall@okay und Precision@okay um etwa 20 %). Die wichtigste Erkenntnis für Ingenieure, die RAG-Systeme entwickeln, besteht darin, dass eine effektive Datenaufbereitung äußerst wichtig ist, um die Spitzenleistung des semantischen Retrieval-/RAG-Programs zu erreichen.

Referenzen

(1) Vollständiger Experimentcode https://colab.analysis.google.com/drive/1dTgt6xwmA6CeIKE38lf2cZVahaJNbQB1?usp=sharing
(2) Modell https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2
(3) Amazon ESCI-Datensatz. Spezifische verwendete Model: https://huggingface.co/datasets/milistu/amazon-esci-data
Der Originaldatensatz ist verfügbar unter https://www.amazon.science/code-and-datasets/shopping-queries-dataset-a-large-scale-esci-benchmark-for-improving-product-search
(4) FAISS https://ai.meta.com/instruments/faiss/

Agile hat in den letzten zwei Jahrzehnten das Software program-Engineering grundlegend verändert. Es reagierte auf das Scheitern groß angelegter Waterfall-Programme, die unter der Final langsamer Anforderungszyklen und umfangreicher Dokumentation zusammenbrachen. Iterative Sprints, teamübergreifende Zusammenarbeit und „Arbeitssoftware statt Dokumentation“ waren die drei großen Grundsätze der Softwarebranche. Die gleiche Beliebtheit, die Agile genießt, hat seine Ineffizienzen verschleiert, wie z. B. die Abschaffung von Zeremonien, ohne dass ein Ende in Sicht ist, die steigenden Gemeinkosten der Rollenspezialisierung und eine Unternehmenskultur, die zunehmend mit ständigen Kontextwechseln auf Kosten der Verantwortlichkeit lebt.

Die Einführung großer Sprachmodelle (LLMs) hat eine erneute Überprüfung ausgelöst. Da KI in der Lage ist, Backlog-Grooming, Aufgabenzerlegung, Testgenerierung, Dokumentation und sogar Architekturentwurf zu übernehmen, gelten die Annahmen, die Agile am Laufen hielten, nicht mehr. Die strukturierte Entwicklung ist wieder auf dem Tisch, nicht als starrer Wasserfall der Vergangenheit, sondern als neues, KI-gestütztes Modell, bei dem lineare Phasen wieder Sinn machen, weil die Übergaben, die früher zu Ausfällen führten, jetzt automatisiert sind. Das ist „Wasserfall 2.0“.

Ein Entwickler, viele Rollen

In der traditionellen Landschaft battle es für einen Entwickler nicht möglich, den gesamten Lebenszyklus im großen Maßstab abzudecken. Ein einzelner Ingenieur könnte Geschäftsanalysen, Architektur, Implementierung, Checks und Dokumentation nicht ohne Verzögerungen und Fehler durchführen. Diese Einschränkung ist nun weg.

Mit LLMs kann die Analyse beschleunigt werden, indem mehrdeutige Anforderungen in strukturierte Annahmen umgewandelt werden. Ein LLM kann eine Reihe von Benutzerinterviews oder Marktnotizen erstellen und Consumer Tales entwerfen, für die andernfalls ein Enterprise-Analyst erforderlich wäre. Während der Entwurfsphase kann das Modell dabei helfen, Architekturmuster vorzuschlagen, Kompromisse zu vergleichen und sogar UML-Diagramme zu erstellen. Während der Implementierung helfen KI-gestützte IDEs beim Code-Gerüst, der Durchsetzung von Styleguides und der Durchführung kontextbezogener Umgestaltungen über Dateien hinweg. Paradoxerweise kann das Testen das LLM sein, das die Logik selbst geschrieben hat und Einheiten-, Integrations- und eigenschaftsbasierte Checks ausgibt, die auf die dokumentierte Teststrategie abgestimmt sind. Während der Bereitstellung könnte man die KI nutzen, um CI/CD-Pipelines, IaC-Vorlagen und Observability-Dashboards zu generieren.

Dies würde einen Arbeitsablauf schaffen, in dem ein Einzelentwickler nicht zum Generalisten werden kann, der zwangsläufig auf der Strecke bleibt, weil er alles wissen muss. In Bezug auf die Produktivität ist der Unterschied nicht nur marginal – es geht darum, die Zeit von Monaten auf Wochen zu verkürzen. Ein Ingenieur könnte ein komplettes Microservices-, Dokumentations- und Überwachungssystem einrichten. Der Engpass liegt nicht mehr in der Ausführung, sondern in der Entscheidungsfindung: was gebaut werden soll und warum.

Beispiele aus der Praxis zeigen diesen Wandel bereits. Produkte, für die früher Groups erforderlich waren, werden jetzt von einzelnen Entwicklern mithilfe von KI auf den Markt gebracht. SiteGPT, ein KI-Chatbot-Builder, wurde an einem einzigen Wochenende programmiert und generierte anschließend erhebliche monatliche Einnahmen. Writesonic, das sich zu einer millionenschweren KI-Schreibplattform entwickelte, begann als Soloprojekt. In einem anderen Fall entwickelte ein Entwickler in nur 15 Tagen Reeli, einen KI-Sprachassistenten in persischer Sprache, indem er Instruments wie Cursor und Claude kombinierte. Dabei handelt es sich nicht um Einzelfälle, sondern um Beweise dafür, dass alleinige KI-gestützte Entwicklung zu Millionengeschäften führen kann.

Arbeitsabläufe neu gedacht

In Groups ist der Effekt noch stärker. Traditionelles Scrum verteilt die Verantwortung auf alle Rollen – Produktbesitzer verfeinern den Backlog, Scrum-Grasp koordinieren Zeremonien, Tester validieren Funktionen und Designer erstellen Modelle. In der Praxis verursacht diese Verteilung jedoch einen Mehraufwand. Agile versprach Geschwindigkeit, lieferte aber häufig Besprechungen ab.

KI komprimiert dies. Die Verfeinerung des Backlogs eines Produktbesitzers wird zu einer nahezu sofortigen Umwandlung roher Besprechungsnotizen in strukturierte Epen und Geschichten, sodass nur noch die Priorisierung der menschlichen Beurteilung überlassen bleibt. Die Funktion des Scrum Masters, Standups und Retrospektiven zu ermöglichen, wird durch KI automatisiert, die tägliche Updates konsolidiert und Blocker aus Commit-Mustern erkennt. Designer stellen fest, dass das Prototyping im Frühstadium von Instruments übernommen wird, die Texteingabeaufforderungen in Wireframes übersetzen, die Entwickler direkt iterieren können. Tester sehen, dass sich ihre Arbeit von der Erstellung von Testfällen hin zur Validierung von KI-generierten Fällen verlagert.

Zeremonien schrumpfen oder verschwinden. Standups werden zu asynchronen Berichten, die von der KI in einem teamweiten Dashboard verarbeitet werden. Die Sprintplanung reduziert sich auf die Genehmigung von KI-generierten Aufgabenaufteilungen. Retrospektiven sind datengesteuert, wobei die KI auf Hotspots in Commit-Protokollen, Code-Änderungen und Fehlerclustern hinweist. Der Nettoeffekt ist kein Chaos, sondern Klarheit. Groups arbeiten jetzt in strukturierten Abläufen, die wie lineare Anforderungen aussehen: Design, Construct, Take a look at und Launch, behalten aber die Agilität, jeden Schritt sofort zu überarbeiten, da die KI die Wiederholungen und Überarbeitungen übernimmt.

Artefakte im KI-Zeitalter

Artefakte, einst die Achillesferse des Wasserfalls, werden in diesem neuen Modell neu definiert. Das klassische Downside bestand darin, dass Dokumente schneller alterten, als sie aktualisiert werden konnten. Architekturentscheidungen, die einmal geschrieben wurden, spiegelten sechs Monate später nur selten die Realität wider. Onboarding-Handbücher waren am Tag ihrer Veröffentlichung veraltet. Die Teststrategien waren vage und CI/CD-Pipelines wurden zu brüchigen Skripten, die niemand pflegte.

Mit der KI im Kreislauf werden Artefakte zu lebendigen Eingaben. Ein Architekturentscheidungsdatensatz kann mit Alternativen, Konsequenzen und Empfehlungen generiert, vom Architekten verfeinert und in der Versionskontrolle gespeichert werden. Dieser Datensatz ist der von der KI selbst genutzte Kontext und steuert die konsistente Generierung später im Projekt. Als Klartext gespeicherte Styleguides werden nicht nur zu Referenzen, sondern zu durchsetzbaren Regeln, da LLM-basierte Linters sie automatisch anwenden.

Die Onboarding-Dokumentation wird kontinuierlich aktualisiert. Anstatt dass ein Mensch die FAQs verwaltet, durchsucht die KI Repositories, Subject-Tracker und Commit-Verläufe, um Leitfäden zu aktualisieren. Ein neuer Mitarbeiter liest kein statisches PDF, sondern befragt einen Onboarding-Assistenten, der die Antworten mit der neuesten Codebasis kontextualisiert. Teststrategien, die einst in der Verantwortung des Menschen lagen, entwickeln sich zu einer Reihe übergeordneter Abdeckungsziele, während die KI die konkreten Testsuiten generiert. Pipelines sind keine handcodierten YAML-Dateien mehr, sondern von der KI vorgeschlagene Konfigurationen, die sich mit dem Projekt weiterentwickeln. Sobald Sicherheitschecklisten in Compliance-Dokumenten vergraben sind, werden sie zu Dwell-Eingabeaufforderungen, anhand derer die KI den Code kontinuierlich prüft.

Das Ergebnis ist eine geschlossene Rückkopplungsschleife: Artefakte werden schneller erstellt, bleiben länger präzise und dienen als direkte Anweisungen sowohl für menschliche Entwickler als auch für KI-Systeme.

Geschwindigkeit mit Risiken in Einklang bringen

Die Effizienzgewinne sind unbestreitbar, aber die Risiken sind struktureller Natur und erfordern ein bewusstes Administration. KI-generierter Code ist zwar schnell, aber anfällig für subtile Fehler. Die Entwürfe weisen auf eine höhere Fehler- und Schwachstellenquote hin, wenn LLMs nicht überprüft werden. Hinzu kommen Ausführlichkeit und Doppelarbeit, die die technische Verschuldung erhöhen und die Wartung erschweren. LLMs leiden auch unter Einschränkungen des Kontextfensters, was bedeutet, dass sie nicht ein ganzes Großsystem in ihrem Umfang aufnehmen können. Dies führt zu Inkonsistenzen zwischen den Modulen und einer fragmentierten Architekturkohärenz.

Es besteht auch das kognitive Risiko: übermäßiges Vertrauen. Wenn Entwickler KI-generierte Artefakte ohne Prüfung akzeptieren, verlieren sie nach und nach das mentale Modell ihres eigenen Techniques. Das Verständnis verkümmert, und was bleibt, ist eher Orchestrierung als Technik. Der kurzfristige Geschwindigkeitsgewinn wird zu einer langfristigen Belastung für die Widerstandsfähigkeit.

Die richtige Reaktion besteht nicht darin, sich zurückzuziehen, sondern die technische Disziplin zu verstärken. Die Codeüberprüfung gewinnt wieder an Bedeutung, nicht als Ritual, sondern als Schutzmaßnahme gegen selbstbewusste Fehler der KI. Automatisierte Checks müssen über die Korrektheit hinaus auf die Sicherheits- und Leistungsvalidierung ausgeweitet werden. Die Überwachung der Architektur ist von entscheidender Bedeutung, um sicherzustellen, dass KI-generierte Mikroentscheidungen weiterhin dem größeren Systemdesign dienen. Tatsächlich muss KI wie ein Nachwuchsentwickler behandelt werden, der nie müde wird, aber immer einer Überprüfung bedarf. Die Rolle des leitenden Entwicklers verlagert sich von der Ausführung zur Leitung, Qualitätssicherung und zum strategischen Design.

Die Zukunft von Bildung und Kompetenzen

Die wechselnden Wellen dieser Veränderungen werden sich weiterhin auf die gesamte Bildung und die Vorbereitung der Arbeitskräfte auswirken. Universitäten, die weiterhin Programmieren lehren, als ob es keine KI gäbe, werden ihre Absolventen in Verzug bringen. Wenn man sich in Einführungskursen hingegen zu sehr auf KI verlässt, besteht möglicherweise die Gefahr, dass Ingenieure nicht in der Lage sind, ohne Krücke zu programmieren. Die Bilanz ist dünn.

Dies legt nahe, die KI-lastige Integration zu verzögern, bis die Studierenden die Grundlagen von Algorithmen, Debugging und Systemdesign beherrschen. Erst dann sollte KI als Kollaborateur eingeführt werden. Einige Programme experimentieren bereits mit Doppelaufgaben: Ein Satz wird ohne KI abgeschlossen, ein anderer mit KI, um sowohl Unabhängigkeit als auch Erweiterungsfähigkeiten zu vermitteln.

Die Fähigkeiten, die am wichtigsten sind, verändern sich. Eine zeitnahe Konstruktion ist nicht trivial; Zu wissen, wie Anforderungen präzise formuliert werden können, ist heute eine zentrale technische Aufgabe. Kritische Bewertung wird zu einer Überlebensfähigkeit, da Ingenieure der KI-Ergebnisse regelmäßig misstrauen und sie überprüfen müssen. DevOps erweitert sich zu KI-erweiterten Pipelines, in denen Ingenieure KI-Module integrieren, überwachen und neu trainieren müssen. Ethik und Compliance rücken in den Vordergrund, da KI-gesteuerte Systeme das Risiko von Voreingenommenheit und Datenschutzverletzungen verstärken.

Der Arbeitsmarkt verändert sich bereits. Neue Titel wie „LLM Engineer“ oder „AI-Augmented Developer“ signalisieren die Nachfrage nach Fachkräften, die technische Tiefe mit der Fähigkeit kombinieren, KI über den gesamten Lebenszyklus hinweg zu steuern. Wer sowohl die Grundlagen als auch die Zusammenarbeit mit KI fließend beherrscht, wird das nächste Jahrzehnt der Softwareentwicklung bestimmen.

Abschluss

Wasserfall 2.0 ist keine Nostalgie. Es ist das rationale Ergebnis eines neuen Gleichgewichts: Wenn KI die Engpässe bei Übergaben beseitigt, gewinnen strukturierte Phasen wieder an Wert. Solo-Entwickler erreichen nun das, was früher Groups erforderten. Groups fassen Rollen und Zeremonien in optimierten Abläufen zusammen. Artefakte entwickeln sich zu lebendigen Inputs, die sowohl die menschliche Zusammenarbeit als auch die KI-Generierung vorantreiben. Die Bildung rüstet sich für eine Zukunft um, in der die Beherrschung von KI ebenso wichtig ist wie die Beherrschung von Code.

Die Risiken, von technischer Verschuldung bis zum Verlust des Verständnisses, sind actual, aber sie sind kein Hingucker. Sie erfordern Disziplin, Kontrolle und ein klares Verständnis dafür, wo menschliches Urteilsvermögen unersetzlich bleibt.

Die Softwareindustrie tritt in eine Section ein, in der die entscheidende Fähigkeit nicht nur im Codieren oder Verwalten, sondern auch in der Orchestrierung von KI innerhalb strukturierter Systeme liegt. Wer dieses Gleichgewicht schafft, wird schnellere, konsistentere und belastbarere Software program entwickeln – nicht weil er die Lehren der Vergangenheit aufgegeben hat, sondern weil er verstanden hat, wie er sie in das Zeitalter der KI übertragen kann.

Hervorgehobener Bildnachweis

DeepSeek-AI hat 3B DeepSeek-OCR veröffentlicht, ein Finish-to-Finish-OCR- und Dokumentenparsing-Imaginative and prescient-Language-Mannequin-(VLM)-System, das langen Textual content in einen kleinen Satz von Imaginative and prescient-Tokens komprimiert und diese Token dann mit einem Sprachmodell dekodiert. Die Methode ist einfach: Bilder enthalten kompakte Textdarstellungen, was die Sequenzlänge für den Decoder reduziert. Das Forschungsteam berichtet von einer Dekodierungsgenauigkeit von 97 %, wenn Textual content-Tokens innerhalb des 10-fachen Bereichs der Imaginative and prescient-Tokens im Fox-Benchmark liegen, und von einem nützlichen Verhalten selbst bei 20-facher Komprimierung. Es werden auch Wettbewerbsergebnisse auf OmniDocBench mit weitaus weniger Token als bei herkömmlichen Basiswerten gemeldet.

Architektur, was ist eigentlich neu?

DeepSeek-OCR-3B besteht aus zwei Komponenten, einem Imaginative and prescient-Encoder namens DeepEncoder und einem Combination of Specialists-Decoder namens DeepSeek3B-MoE-A570M. Der Encoder ist für hochauflösende Eingaben mit geringen Aktivierungskosten und wenigen Ausgabe-Tokens konzipiert. Es verwendet eine auf SAM basierende Fenster-Aufmerksamkeitsstufe für die lokale Wahrnehmung, einen zweischichtigen Faltungskompressor für 16-faches Token-Downsampling und eine dichte globale Aufmerksamkeitsstufe auf Foundation von CLIP für die visuelle Wissensaggregation. Durch dieses Design wird der Aktivierungsspeicher bei hoher Auflösung kontrolliert und die Anzahl der Imaginative and prescient-Tokens niedrig gehalten. Der Decoder ist ein 3B-Parameter-MoE-Modell (genannt als DeepSeek3B-MoE-A570M) mit etwa 570 Millionen aktiven Parametern professional Token.

Modi mit mehreren Auflösungen, entwickelt für Token-Budgets

DeepEncoder unterstützt native Modi und dynamische Modi. Native Modi sind Tiny mit 64 Token bei 512 x 512 Pixeln, Small mit 100 Token bei 640 x 640, Base mit 256 Token bei 1024 x 1024 und Giant mit 400 Token bei 1280 x 1280. Dynamische Modi namens Gundam und Gundam-Grasp mischen gekachelte lokale Ansichten mit einer globalen Ansicht. Gundam ergibt n×100 plus 256 Token oder n×256 plus 400 Token, wobei n im Bereich von 2 bis 9 liegt. Für gepolsterte Modi gibt das Forschungsteam eine Formel für gültige Token an, die niedriger ist als die rohe Tokenanzahl und vom Seitenverhältnis abhängt. Mit diesen Modi können KI-Entwickler und -Forscher die Token-Budgets an die Seitenkomplexität anpassen.

Komprimierungsergebnisse, was die Zahlen sagen…..

Die Fox-Benchmark-Studie misst die Präzision als exakte Textübereinstimmung nach der Dekodierung. Mit 100 Imaginative and prescient-Tokens erreichen Seiten mit 600 bis 700 Textual content-Tokens eine Genauigkeit von 98,5 % bei 6,7-facher Komprimierung. Seiten mit 900 bis 1000 Textual content-Tokens erreichen eine Genauigkeit von 96,8 % bei 9,7-facher Komprimierung. Bei 64 Imaginative and prescient-Tokens nimmt die Präzision mit zunehmender Komprimierung ab, beispielsweise 59,1 % bei etwa 19,7× für 1200 bis 1300 Textual content-Tokens. Diese Werte stammen direkt aus Tabelle 2.

Auf OmniDocBench berichtet die Zusammenfassung, dass DeepSeek-OCR GOT-OCR 2.0 übertrifft, wenn nur 100 Imaginative and prescient-Tokens professional Seite verwendet werden, und dass es bei weniger als 800 Imaginative and prescient-Tokens MinerU 2.0 übertrifft, das im Durchschnitt über 6000 Tokens professional Seite verwendet. Der Benchmark-Bereich stellt die Gesamtleistung in Bezug auf die Bearbeitungsentfernung dar.

Trainingsdetails, die wichtig sind….

Das Forschungsteam beschreibt eine zweiphasige Trainingspipeline. Es trainiert DeepEncoder zunächst mit der nächsten Token-Vorhersage für OCR 1.0- und OCR 2.0-Daten und 100 Millionen LAION-Proben und trainiert dann das gesamte System mit Pipeline-Parallelität über 4 Partitionen. Als {Hardware} nutzte der Lauf 20 Knoten mit jeweils 8 A100 40G-GPUs und AdamW. Das Staff meldet eine Trainingsgeschwindigkeit von 90 Milliarden Token professional Tag für reine Textdaten und 70 Milliarden Token professional Tag für multimodale Daten. In der Produktion wird die Fähigkeit gemeldet, über 200.000 Seiten professional Tag auf einem einzigen A100 40G-Knoten zu generieren.

So bewerten Sie es in einem praktischen Stapel

Wenn es sich bei Ihren Zieldokumenten um typische Berichte oder Bücher handelt, beginnen Sie mit dem kleinen Modus bei 100 Token und passen Sie ihn dann nur dann nach oben an, wenn der Bearbeitungsabstand nicht akzeptabel ist. Wenn Ihre Seiten dichte kleine Schriftarten oder eine sehr hohe Token-Anzahl enthalten, verwenden Sie einen Gundam-Modus, da dieser globale und lokale Sichtfelder mit expliziter Token-Budgetierung kombiniert. Wenn Ihre Arbeitslast Diagramme, Tabellen oder chemische Strukturen umfasst, lesen Sie den qualitativen Abschnitt „Deep Parsing“, der Konvertierungen in HTML-Tabellen und SMILES sowie strukturierte Geometrie zeigt, und entwerfen Sie dann Ausgaben, die leicht zu validieren sind.

Wichtige Erkenntnisse

1. DeepSeek OCR zielt auf die Token-Effizienz durch optische Kontextkomprimierung mit nahezu verlustfreier Dekodierung bei etwa 10-facher Komprimierung und etwa 60 Prozent Präzision bei etwa 20-facher Komprimierung ab.
2. Die HF-Model legt explizite Token-Budgets offen: Tiny verwendet 64 Token bei 512 x 512, Small verwendet 100 Token bei 640 x 640, Base verwendet 256 Token bei 1024 x 1024, Giant verwendet 400 Token bei 1280 x 1280 und Gundam erstellt n Ansichten bei 640 x 640 plus eine globale Ansicht bei 1024 mal 1024.
3. Die Systemstruktur besteht aus einem DeepEncoder, der Seiten in Imaginative and prescient-Tokens komprimiert, und einem DeepSeek3B-MoE-Decoder mit etwa 570 Millionen aktiven Parametern, wie vom Forschungsteam im technischen Bericht beschrieben.
4. Die Hugging Face-Modellkarte dokumentiert ein getestetes Setup für den sofortigen Einsatz: Python 3.12.9, CUDA 11.8, PyTorch 2.6.0, Transformers 4.46.3, Tokenizers 0.20.3 und Flash Consideration 2.7.3.

DeepSeek OCR ist ein praktischer Schritt für die Dokumenten-KI. Es behandelt Seiten als kompakte optische Träger, die die Länge der Decodersequenz reduzieren, ohne die meisten Informationen zu verwerfen. Die Modellkarte und der technische Bericht beschreiben eine Decodierungsgenauigkeit von 97 Prozent bei etwa zehnfacher Komprimierung im Fox-Benchmark, was die wichtigste Aussage zum Testen in realen Arbeitslasten ist. Das veröffentlichte Modell ist ein 3B MoE-Decoder mit einem DeepEncoder-Frontend, verpackt für Transformers, mit getesteten Versionen für PyTorch 2.6.0, CUDA 11.8 und Flash Consideration 2.7.3, was die Einrichtungskosten für Ingenieure senkt. Das Repository zeigt einen einzelnen Safetensors-Shard mit 6,67 GB, der für gängige GPUs geeignet ist. Insgesamt operationalisiert DeepSeek OCR die optische Kontextkomprimierung mit einem 3B-MoE-Decoder, meldet eine Dekodierungsgenauigkeit von etwa 97 % bei 10-facher Komprimierung auf Fox, bietet explizite Token-Funds-Modi und beinhaltet ein getestetes Transformers-Setup, um den Durchsatzanspruch in Ihrer eigenen Pipeline zu validieren.

Schauen Sie sich das an Technisches Papier, Modell auf HF Und GitHub-Repo. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

Langextrakt ist ein von Entwickler bei Google Dadurch wird es einfach, unordentliche, unstrukturierte Textual content in saubere, strukturierte Daten zu verwandeln, indem Sie LLMs nutzen. Benutzer können einige wenige Beispiele zusammen mit einem benutzerdefinierten Schema angeben und darauf basieren. Es funktioniert sowohl mit proprietärer als auch mit lokaler LLMs (über Ollama).

Eine erhebliche Menge an Daten im Gesundheitswesen ist unstrukturiert, was es zu einem idealen Bereich macht, in dem ein Device wie dieses von Vorteil sein kann. Klinische Notizen sind lang und voller Abkürzungen und Inkonsistenzen. Wichtige Particulars wie Drogennamen, Dosierungen und insbesondere unerwünschte Arzneimittelreaktionen (ADRs) werden im Textual content begraben. Daher wollte ich für diesen Artikel sehen, ob Langextract in klinischen Notizen eine nachteilige Erkennung von Arzneimittelreaktion (ADR) bewältigen könnte. Noch wichtiger ist, ist es effektiv? Lassen Sie uns in diesem Artikel herausfinden. Beachten Sie, dass Langextract zwar ein Open-Supply-Projekt von Entwicklern bei Google ist, es jedoch kein offiziell unterstütztes Google-Produkt ist.

Nur ein kurzer Hinweis: Ich zeige nur, wie Lanextraden funktioniert. Ich bin kein Arzt, und das ist kein medizinischer Rat.

hier ist detailliert Kaggle Pocket book mit folgen.

Warum ADR Extraktion wichtig ist

Ein Unerwünschte Arzneimittelreaktion (ADR) ist ein schädliches, unbeabsichtigtes Ergebnis, das durch Einnahme eines Medikaments verursacht wird. Diese können von leichten Nebenwirkungen wie Übelkeit oder Schwindel bis hin zu schwerwiegenden Ergebnissen reichen, die möglicherweise medizinische Hilfe erfordern.

Es ist entscheidend für die Patientensicherheit und die schnelle Erkennung von entscheidender Bedeutung und Pharmakovigilanz. Die Herausforderung besteht darin, dass in klinischen Notizen ADRs zusammen mit früheren Bedingungen, Laborergebnissen und einem anderen Kontext begraben werden. Infolgedessen ist es schwierig, sie zu erkennen. Die Verwendung von LLMs zur Erkennung von ADRs ist ein fortlaufender Forschungsbereich. Manche Neuere Arbeiten haben gezeigt, dass LLMs intestine darin sind, rote Fahnen zu heben, aber nicht zuverlässig. Die ADR -Extraktion ist additionally ein guter Stresstest für Langextract, da das Ziel hier darin besteht, festzustellen, ob diese Bibliothek die nachteiligen Reaktionen unter anderen Einheiten in klinischen Notizen wie Medikamenten, Dosierungen, Schweregrad usw. erkennen kann.

Wie Langextract funktioniert

Bevor wir in die Verwendung einsteigen, lasst uns Langextracts Workflow aufschlüsseln. Es ist ein einfacher dreistufiger Prozess:

1. Definieren Sie Ihre Extraktionsaufgabe Durch das Schreiben einer klaren Eingabeaufforderung, die genau angibt, was Sie extrahieren möchten.
2. Bieten Sie einige hochwertige Beispiele an Um das Modell in Richtung des von Ihnen erwarteten Codecs und Detaillierungsgrades zu führen.
3. Senden Sie Ihren Eingangstext, wählen Sie das Modell und lassen Sie es Langextract verarbeiten. Benutzer können Überprüfen Sie dann die Ergebnisse, visualisieren Sie sie oder geben Sie sie direkt in ihre nachgelagerte Pipeline ein.

Der Beamte Github -Repository des Instruments enthält detaillierte Beispiele, die mehrere Domänen umfassen, von der Entitätsextraktion in Shakespeares Romeo & Julia bis hin zu Medikamentenidennings in klinischen Notizen und Strukturierung der Radiologieberichte. Schau sie dir an.

Set up

Zuerst müssen wir die installieren LangExtract Bibliothek. Es ist immer eine gute Idee, dies innerhalb eines zu tun Virtuelle Umgebung um Ihre Projektabhängigkeiten isoliert zu halten.

pip set up langextract

Identifizierung unerwünschter Arzneimittelreaktionen in klinischen Notizen mit Langextract & Gemini

Kommen wir nun zu unserem Anwendungsfall. Für diesen Vorgang werde ich Google verwenden Gemini 2.5 Flash Modell. Sie könnten auch verwenden Gemini Professional Für komplexere Argumentationsaufgaben. Sie müssen zuerst Ihren API -Schlüssel einstellen:

export LANGEXTRACT_API_KEY="your-api-key-here"

hier ist detailliert Kaggle Pocket book mit folgen.

Schritt 1: Definieren Sie die Extraktionsaufgabe

Lassen Sie uns unsere Aufforderung zum Extrahieren von Medikamenten, Dosierungen, nachteiligen Reaktionen und Maßnahmen erstellen. Wir können auch nach Erwähnung um Schweregrad bitten.

immediate = textwrap.dedent("""
Extract medicine, dosage, hostile response, and motion taken from the textual content.
For every hostile response, embrace its severity as an attribute if talked about.
Use actual textual content spans from the unique textual content. Don't paraphrase.
Return entities within the order they seem.""")

Lassen Sie uns als nächstes ein Beispiel geben, um das Modell zum richtigen Format zu führen:

# 1) Outline the immediate
immediate = textwrap.dedent("""
Extract situation, medicine, dosage, hostile response, and motion taken from the textual content.
For every hostile response, embrace its severity as an attribute if talked about.
Use actual textual content spans from the unique textual content. Don't paraphrase.
Return entities within the order they seem.""")

# 2) Instance 
examples = (
    lx.information.ExampleData(
        textual content=(
            "After taking ibuprofen 400 mg for a headache, "
            "the affected person developed delicate abdomen ache. "
            "They stopped taking the medication."
        ),
        extractions=(
            
            lx.information.Extraction(
                extraction_class="situation",
                extraction_text="headache"
            ),
        
            lx.information.Extraction(
                extraction_class="medicine",
                extraction_text="ibuprofen"
            ),
            lx.information.Extraction(
                extraction_class="dosage",
                extraction_text="400 mg"
            ),
            lx.information.Extraction(
                extraction_class="adverse_reaction",
                extraction_text="delicate abdomen ache",
                attributes={"severity": "delicate"}
            ),
            lx.information.Extraction(
                extraction_class="action_taken",
                extraction_text="They stopped taking the medication"
            )
        )
    )
)

Schritt 2: Geben Sie die Eingabe an und führen Sie die Extraktion aus

Für die Eingabe verwende ich einen echten klinischen Satz aus dem Ade Corpus v2 Datensatz zum Umarmungsgesicht.

input_text = (
    "A 27-year-old man who had a historical past of bronchial bronchial asthma, "
    "eosinophilic enteritis, and eosinophilic pneumonia introduced with "
    "fever, pores and skin eruptions, cervical lymphadenopathy, hepatosplenomegaly, "
    "atypical lymphocytosis, and eosinophilia two weeks after receiving "
    "trimethoprim (TMP)-sulfamethoxazole (SMX) remedy."
)

Lassen Sie uns als nächstes Langextract mit dem Gemini-2,5-Flash-Modell ausführen.

end result = lx.extract(
    text_or_documents=input_text,
    prompt_description=immediate,
    examples=examples,
    model_id="gemini-2.5-flash",
    api_key=LANGEXTRACT_API_KEY 
)

Schritt 3: Zeigen Sie die Ergebnisse an

Sie können die extrahierten Einheiten mit Positionen anzeigen

print(f"Enter: {input_text}n")
print("Extracted entities:")
for entity in end result.extractions:
    position_info = ""
    if entity.char_interval:
        begin, finish = entity.char_interval.start_pos, entity.char_interval.end_pos
        position_info = f" (pos: {begin}-{finish})"
    print(f"• {entity.extraction_class.capitalize()}: {entity.extraction_text}{position_info}")

Langextract identifiziert die korrekt die unerwünschte Arzneimittelreaktion Ohne es mit den bereits bestehenden Bedingungen des Patienten zu verwechseln, was bei dieser Artwork von Aufgabe eine zentrale Herausforderung darstellt.

Wenn Sie es visualisieren möchten, wird dies erstellen .jsonl Datei. Sie können das laden .jsonl Datei durch Aufrufen der Visualisierungsfunktion und erstellt eine HTML -Datei für Sie.

lx.io.save_annotated_documents(
    (end result),
    output_name="adr_extraction.jsonl",
    output_dir="."
)

html_content = lx.visualize("adr_extraction.jsonl")

# Show the HTML content material straight
show((html_content))

Arbeiten mit längeren klinischen Notizen

Echte klinische Notizen sind oft viel länger als das oben gezeigte Beispiel. Zum Beispiel finden Sie hier eine tatsächliche Notiz aus der Ade-Corpus-V2 Datensatz unter dem MIT -Lizenz. Sie können darauf zugreifen Umarmtes Gesicht oder Zenodo.

Um längere Texte mit Langextract zu verarbeiten, führen Sie den gleichen Workflow bei, fügen jedoch drei Parameter hinzu:

Extraction_Passe Führen Sie mehrere Pässe über den Textual content aus, um weitere Particulars zu erhalten und den Rückruf zu verbessern.

Max_worker Steuerelemente parallele Verarbeitung, sodass größere Dokumente schneller behandelt werden können.

max_char_buffer Teilen den Textual content in kleinere Stücke auf, was dem Modell hilft, auch dann genau zu bleiben, wenn die Eingabe sehr lang ist.

end result = lx.extract(
    text_or_documents=input_text,
    prompt_description=immediate,
    examples=examples,
    model_id="gemini-2.5-flash",
    extraction_passes=3,    
    max_workers=20,         
    max_char_buffer=1000   
)

Hier ist die Ausgabe. Für die Kürze zeige ich hier nur einen Teil der Ausgabe.

Wenn Sie möchten, können Sie auch die URL eines Dokuments direkt an die übergeben text_or_documents Parameter.

Verwenden von Langextract mit lokalen Modellen über Ollama

Langextract ist nicht auf proprietäre APIs beschränkt. Sie können es auch mit lokalen Modellen durchführen Ollama. Dies ist besonders nützlich, wenn Sie mit Datenschutz-sensitiven klinischen Daten arbeiten, die Ihre sichere Umgebung nicht verlassen können. Sie können Ollama lokal einrichten, Ihr bevorzugtes Modell ziehen und Langextract darauf hinweisen. Vollständige Anweisungen finden Sie in der offizielle Dokumente.

Abschluss

Wenn Sie ein Informationsabrufsystem oder eine Anwendung mit Metadatenextraktion erstellen, kann Langextract Ihnen eine erhebliche Menge an Vorverarbeitungsaufwand ersparen. In meinen ADR -Experimenten führte Langextract intestine ab und identifizierte Medikamente, Dosierungen und Reaktionen korrekt. Ich habe festgestellt, dass die Ausgabe direkt von der Qualität der wenigen Schussbeispiele des Benutzers abhängt, was bedeutet, dass LLMs das schwere Heben durchführen, aber immer noch ein wichtiger Teil der Schleife bleiben. Die Ergebnisse waren ermutigend, aber da klinische Daten ein hohes Risiko sind, sind weiterhin breitere und strengere Exams in verschiedenen Datensätzen erforderlich, bevor sie zur Produktionsanwendung bewegt werden.

Robustheit und Determinismus in LLM-Anwendungen aufbauen

OpenAI vor kurzem angekündigt Unterstützung für Strukturierte Ausgaben in seiner neuesten gpt-4o-2024–08–06 Modelle. Strukturierte Ausgaben im Zusammenhang mit großen Sprachmodellen (LLMs) sind nichts Neues – Entwickler haben entweder verschiedene Immediate-Engineering-Techniken oder Instruments von Drittanbietern verwendet.

In diesem Artikel erklären wir, was strukturierte Ausgaben sind, wie sie funktionieren und wie Sie sie in Ihren eigenen LLM-basierten Anwendungen anwenden können. Obwohl die Ankündigung von OpenAI die Implementierung mithilfe ihrer APIs recht einfach macht (wie wir hier zeigen werden), möchten Sie sich vielleicht stattdessen für die Open-Supply-Model entscheiden. Umrisse Paket (gepflegt von den netten Leuten bei dottxt), da es sowohl auf die selbstgehosteten Open-Weight-Modelle (z. B. Mistral und LLaMA) als auch auf die proprietären APIs (Haftungsausschluss: wegen dieses Drawback Outlines unterstützt zum Zeitpunkt des Schreibens dieses Artikels noch nicht die strukturierte JSON-Generierung über OpenAI-APIs; das wird sich jedoch bald ändern!).

Wenn RedPajama-Datensatz ist ein Hinweis, dass die überwiegende Mehrheit der vor dem Coaching gewonnenen Daten menschlicher Textual content ist. Daher ist „natürliche Sprache“ die native Domäne von LLMs – sowohl bei der Eingabe als auch bei der Ausgabe. Wenn wir jedoch Anwendungen erstellen, möchten wir maschinenlesbare formale Strukturen oder Schemata verwenden, um unsere Dateneingabe/-ausgabe zu kapseln. Auf diese Weise bauen wir Robustheit und Determinismus in unsere Anwendungen ein.

Strukturierte Ausgaben ist ein Mechanismus, mit dem wir ein vordefiniertes Schema für die LLM-Ausgabe erzwingen. Dies bedeutet normalerweise, dass wir ein JSON-Schema erzwingen, es ist jedoch nicht nur auf JSON beschränkt – wir könnten grundsätzlich XML, Markdown oder ein vollständig benutzerdefiniertes Schema erzwingen. Die Vorteile strukturierter Ausgaben sind zweifach:

1. Einfacheres Immediate-Design — wir brauchen nicht seien Sie zu ausführlich, wenn Sie angeben, wie die Ausgabe aussehen soll
2. Deterministische Namen und Typen — wir können Garantie um beispielsweise ein Attribut zu erhalten age mit einem Quantity JSON-Typ in der LLM-Antwort

Für dieses Beispiel verwenden wir den ersten Satz aus Sam Altmans Wikipedia-Eintrag…

Samuel Harris Altman (* 22. April 1985) ist ein US-amerikanischer Unternehmer und Investor, der vor allem seit 2019 als CEO von OpenAI bekannt ist (er wurde kurzzeitig entlassen und im November 2023 wieder eingestellt).

…und wir werden den neuesten GPT-4o-Checkpoint als Named-Entity-Recognition-System (NER) verwenden. Wir werden das folgende JSON-Schema erzwingen:

json_schema = {
"identify": "NamedEntities",
"schema": {
"sort": "object",
"properties": {
"entities": {
"sort": "array",
"description": "Record of entity names and their corresponding varieties",
"gadgets": {
"sort": "object",
"properties": {
"identify": {
"sort": "string",
"description": "The precise identify as specified within the textual content, e.g. an individual's identify, or the identify of the nation"
},
"sort": {
"sort": "string",
"description": "The entity sort, resembling 'Particular person' or 'Group'",
"enum": ("Particular person", "Group", "Location", "DateTime")
}
},
"required": ("identify", "sort"),
"additionalProperties": False
}
}
},
"required": ("entities"),
"additionalProperties": False
},
"strict": True
}

Im Wesentlichen sollte unsere LLM-Antwort enthalten: NamedEntities Objekt, das aus einem Array von entitiesjede enthält eine identify Und sort. Hier gibt es einige Dinge zu beachten. Wir können zum Beispiel erzwingen Aufzählung Typ, was in NER sehr nützlich ist, da wir die Ausgabe auf einen festen Satz von Entitätstypen beschränken können. Wir müssen alle Felder im required Array: Wir können jedoch auch „optionale“ Felder emulieren, indem wir den Typ beispielsweise auf ("string", null) .

Wir können nun unser Schema zusammen mit den Daten und Anweisungen an die API übergeben. Wir müssen die response_format Streit mit einem diktieren wo wir sort Zu "json_schema” und geben Sie dann das entsprechende Schema an.

completion = consumer.beta.chat.completions.parse(
mannequin="gpt-4o-2024-08-06",
messages=(
{
"function": "system",
"content material": """You're a Named Entity Recognition (NER) assistant.
Your job is to establish and return all entity names and their 
varieties for a given piece of textual content. You might be to strictly conform
solely to the next entity varieties: Particular person, Location, Group
and DateTime. If unsure about entity sort, please ignore it.
Watch out of sure acronyms, resembling function titles "CEO", "CTO",
"VP", and so forth - these are to be ignore.""",
},
{
"function": "consumer",
"content material": s
}
),
response_format={
"sort": "json_schema",
"json_schema": json_schema,
}
)

Die Ausgabe sollte ungefähr so ​​aussehen:

{   'entities': (   {'identify': 'Samuel Harris Altman', 'sort': 'Particular person'},
{'identify': 'April 22, 1985', 'sort': 'DateTime'},
{'identify': 'American', 'sort': 'Location'},
{'identify': 'OpenAI', 'sort': 'Group'},
{'identify': '2019', 'sort': 'DateTime'},
{'identify': 'November 2023', 'sort': 'DateTime'})}

Der vollständige Quellcode, der in diesem Artikel verwendet wird, ist verfügbar Hier.

Die Magie liegt in der Kombination von eingeschränkte StichprobennahmeUnd kontextfreie Grammatik (CFG). Wir haben bereits erwähnt, dass die überwiegende Mehrheit der vor dem Coaching gewonnenen Daten aus „natürlicher Sprache“ besteht. Statistisch gesehen bedeutet dies, dass bei jedem Dekodierungs-/Abtastschritt eine nicht zu vernachlässigende Wahrscheinlichkeit besteht, ein beliebiges Token aus dem erlernten Vokabular abzutasten (und in modernen LLMs umfassen Vokabulare normalerweise über 40.000 Token). Beim Umgang mit formalen Schemata möchten wir jedoch alle unwahrscheinlichen Token schnell eliminieren.

Wenn wir im vorherigen Beispiel bereits Folgendes generiert haben …

{   'entities': (   {'identify': 'Samuel Harris Altman',

…dann würden wir im Idealfall einen sehr hohen Logit-Bias auf die 'typ Token im nächsten Dekodierungsschritt und sehr geringe Wahrscheinlichkeit für alle anderen Token im Vokabular.

Im Wesentlichen passiert Folgendes. Wenn wir das Schema bereitstellen, wird es in eine formale Grammatik (CFG) umgewandelt, die dazu dient, die Logit-Bias-Werte während des Dekodierungsschritts zu steuern. CFG ist einer dieser altmodischen Mechanismen der Informatik und der natürlichen Sprachverarbeitung (NLP), der gerade ein Comeback erlebt. Eine sehr schöne Einführung in CFG wurde tatsächlich in diese StackOverflow-Antwortim Wesentlichen handelt es sich jedoch um eine Möglichkeit, Transformationsregeln für eine Sammlung von Symbolen zu beschreiben.

Strukturierte Ausgaben sind nichts Neues, aber sie werden mit proprietären APIs und LLM-Diensten immer wichtiger. Sie bilden eine Brücke zwischen dem sprunghaften und unvorhersehbaren „natürlichen Sprachbereich“ der LLMs und dem deterministischen und strukturierten Bereich der Softwareentwicklung. Strukturierte Ausgaben sind im Wesentlichen muss für alle, die komplexe LLM-Anwendungen entwickeln, bei denen LLM-Ausgaben in verschiedenen Komponenten geteilt oder „präsentiert“ werden müssen. Obwohl es nun endlich API-native Unterstützung gibt, sollten Entwickler auch die Verwendung von Bibliotheken wie Outlines in Betracht ziehen, da diese eine LLM/API-agnostische Möglichkeit bieten, mit strukturierter Ausgabe umzugehen.