Structured Outputs

Beherrschen Sie die Evaluierung von programmatisch formatierten LLM-Antworten, die für agentische Anwendungen essentiell sind

Structured Outputs ermöglichen Entwicklern, sicherzustellen, dass das LLM Antworten in einem programmatisch deterministischen Format erzeugt. Agentische Programme nutzen diese Funktion intensiv, um Interoperabilität zwischen Code-Pfaden und LLM-Antworten zu ermöglichen. Dies macht die Evaluierung structured Outputs zu einem wesentlichen Bestandteil der Evaluierung von Agenten.

Grundlegende Verwendung

Ein Beispiel, das die Verwendung von Pydantic-Modellen für die Generierung und Evaluierung von structured Outputs zeigt:

import asyncio

from elluminate import Client
from elluminate.schemas import RatingMode
from pydantic import BaseModel, Field


class ProductReviewSentimentAnalysis(BaseModel):  # (1)!
    """Schema for structured sentiment analysis of reviews."""

    stars: int = Field(description="Number of stars of the review", ge=1, le=5)
    sentiment: str = Field(
        description="Overall sentiment: positive, negative, or neutral",
        pattern="^(positive|negative|neutral)$",
    )
    confidence: float = Field(description="Confidence score of the sentiment analysis between 0 and 1", ge=0, le=1)


async def main():
    client = Client()

    template, _ = await client.prompt_templates.aget_or_create(  # (2)!
        user_prompt_template="""Analyze this product review and extract key information:

Review: {{review_text}}

Provide review stars, sentiment and confidence score.""",
        name="Product Review Analysis",
        response_format=ProductReviewSentimentAnalysis,
    )

    collection, _ = await client.collections.aget_or_create(
        name="Product Review Data",
        variables=[
            {
                "review_text": "Stars: **** Great wireless headphones! Audio quality is fantastic and noise cancellation works perfectly. Battery could be better but overall very satisfied."
            },
            {
                "review_text": "Stars: ** Poor laptop experience. Screen flickered after 2 weeks, customer service was helpful, but would not recommend this product."
            },
        ],
    )

    await client.criteria.aadd_many(  # (3)!
        [
            "In the 'stars' field, is the counted number of stars correct?"
            "Does the 'sentiment' field accurately reflect the review's tone?",
            "Is the 'confidence' score appropriate for the certainty of the sentiment?",
        ],
        template,
        delete_existing=True,
    )

    experiment, _ = await client.experiments.aget_or_create(  # (4)!
        name="Review Analysis Experiment",
        prompt_template=template,
        collection=collection,
        generate=True,
        rating_mode=RatingMode.FAST,
        block=True,
        n_epochs=1,
    )

    for i, response in enumerate(experiment.rated_responses, 1):  # (5)!
        print(f"Example {i}:")
        print(f"Review: {response.prompt.template_variables.input_values['review_text'][:80]}...")
        print("Analysis:")

        for message in response.messages:
            if message.role == "assistant":
                print(f"{message.content}")
    else:
        print()


if __name__ == "__main__":
    asyncio.run(main())

1. Schema definieren: Erstellen Sie ein Pydantic-Modell mit Feldbeschreibungen und grundlegenden Constraints, um die exakte JSON-Struktur zu definieren, die das LLM zurückgeben soll

2. Template erstellen: Verwenden Sie den Parameter response_format beim Erstellen eines Prompt-Templates, um anzugeben, dass Antworten Ihrer Pydantic-Modellstruktur folgen sollen

3. Kriterien hinzufügen: Definieren Sie Evaluierungskriterien, die sich auf spezifische Schema-Felder beziehen - Kriterien können auch wie gewohnt automatisch generiert werden

4. Experiment ausführen: Erstellen und führen Sie Experimente normal aus - das strukturierte Ausgabeformat wird automatisch für alle Antwortgenerierungen angewendet

5. Auf Antworten zugreifen: Die structured Outputs finden sich im content-Feld der Assistant-Nachricht als JSON-String

Schema-Definitionsmethoden

Pydantic-Modelle

Pydantic-Modelle bieten die intuitivste und empfohlene Art, Schemas für structured Outputs zu definieren. Setzen Sie einfach response_format auf die Pydantic-Klassendefinition, und elluminate übernimmt den Rest.

OpenAI JSON Schema Format

Zusätzlich zu Pydantic-Modellen können Sie auch das response_format direkt mit einer OpenAI JSON Schema-Definition setzen:

schema = {
    "type": "json_schema",
    "json_schema": {
        "name": "sentiment",
        "schema": {
            "type": "object",
            "properties": {
                "stars": {
                    "type": "integer",
                    "description": "Anzahl der Sterne der Bewertung",
                    "minimum": 1,
                    "maximum": 5
                },
                "sentiment": {
                    "type": "string",
                    "description": "Die Stimmungsausgabe, könnte positiv, negativ oder neutral sein.",
                    "enum": [
                        "positive",
                        "negative",
                        "neutral"
                    ]
                },
                "confidence": {
                    "type": "number",
                    "description": "Konfidenzwert der Stimmungsanalyse zwischen 0 und 1",
                    "minimum": 0,
                    "maximum": 1
                }
            },
            "required": [
                "stars",
                "sentiment",
                "confidence"
            ],
            "additionalProperties": False
        }
    }
}

KI-gestützte Schema-Generierung

Das Frontend bietet einen KI-gestützten Schema-Generator, der JSON-Schemas aus natürlichsprachlichen Beschreibungen erstellt. Beschreiben Sie einfach, was Sie extrahieren möchten, und elluminate generiert ein entsprechendes Schema.

Evaluierung von structured Outputs

Das Rating-Modell hat Zugriff auf alle Feldbeschreibungen aus Ihrem Schema für structured Outputs und bietet dadurch wertvollen Kontext darüber, was jedes Feld enthalten sollte und wie es interpretiert werden sollte. Um structured Outputs zu evaluieren, erstellen Sie einfach wie gewohnt Kriterien und führen ein Experiment aus.

Verwendung von Feldnamen in Kriterien

Es kann vorteilhaft sein, Feldnamen aus Ihrem Schema in den Kriterien zu verwenden. Dies hilft dem Rating-Modell zu verstehen, auf welchen Teil der JSON-Struktur es sich genau konzentrieren soll. Zum Beispiel ist "Ist das 'sentiment'-Feld..." präziser als "Ist die Stimmung korrekt?"