Strukturierte Ausgaben

Strukturierte Ausgaben 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 strukturierter Ausgaben zu einem wesentlichen Bestandteil der Evaluierung von Agenten.

Grundlegende Verwendung

Ein Beispiel, das die Verwendung von Pydantic-Modellen für die Generierung und Evaluierung strukturierter Ausgaben 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):
        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']}")  # (5)!
        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 durchgesetzt

5. Auf Antworten zugreifen: Die strukturierten Ausgaben finden sich im content-Schlüssel der Assistant-Nachricht als JSON-String

Schema-Definitionsmethoden

Pydantic-Modelle

Pydantic-Modelle bieten die intuitivste und empfohlene Art, Schemas für strukturierte Ausgaben 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 den 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 strukturierter Ausgaben

Das Rating-Modell hat Zugriff auf alle Feldbeschreibungen aus Ihrem Schema für strukturierte Ausgaben und bietet dadurch wertvollen Kontext darüber, was jedes Feld enthalten sollte und wie es interpretiert werden sollte. Um strukturierte Ausgaben 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?"