Erweiterte API-Funktionen für importierte Modelle

Diese Seite enthält detaillierte Beispiele für erweiterte Funktionen, die für Modelle verfügbar sind, die nach dem 11. November 2025 importiert wurden. Zu diesen Funktionen gehören strukturierte Ausgaben für die kontrollierte Generierung, erweiterte Bildverarbeitungsunterstützung für die Verarbeitung mehrerer Bilder, Log-Wahrscheinlichkeiten für zuverlässige Erkenntnisse und Tools zum Aufrufen von Modellen. GPT-OSS

Strukturierte Ausgaben

Strukturierte Ausgaben ermöglichen eine kontrollierte Generierung nach bestimmten Formaten, Schemas oder Mustern. Diese Funktion stellt sicher, dass die Reaktion des Modells vordefinierten Einschränkungen entspricht. Dadurch eignet es sich ideal für Anwendungen, die konsistente Datenformate, API-Integrationen oder automatisierte Verarbeitungspipelines erfordern.

Strukturierte Ausgaben beim Import benutzerdefinierter Modelle werden über zwei Parameter unterstützt:

• response_format- Unterstützungen json_object und json_schema Typen

• structured_outputs- Unterstützt jsonregex,choice, und grammar Typen

Anmerkung

Bei der Verwendung strukturierter Ausgaben beim Import benutzerdefinierter Modelle müssen Kunden aufgrund der Validierung von Einschränkungen bei der Generierung mit Leistungseinbußen rechnen. Einfache Einschränkungen wie choice und json_object haben nur minimale Auswirkungen, während komplexe Einschränkungen die Latenz erheblich erhöhen json_schema und den Durchsatz reduzieren grammar können. Um eine optimale Leistung zu erzielen, sollten Sie nach Möglichkeit einfachere Einschränkungstypen verwenden und Schemas flach statt tief verschachtelt halten.

Die folgenden Beispiele zeigen, dass strukturierte Ausgaben in verschiedenen API-Formaten unterstützt werden. Die Definition des pydantischen Modells lautet:

from pydantic import BaseModel
from enum import Enum

class CarType(str, Enum):
    sedan = "sedan"
    suv = "SUV"
    truck = "Truck"
    coupe = "Coupe"

class CarDescription(BaseModel):
    brand: str
    model: str
    car_type: CarType

BedrockCompletion

BedrockCompletion unterstützt strukturierte Ausgaben, bei denen nur die response_format Parameter with json_object und json_schema types verwendet werden.

Beispiel: JSON-Schema

payload = {
    "prompt": "Generate a JSON with the brand, model and car_type of the most iconic car from the 90's",
    "response_format": {
        "type": "json_schema",
        "json_schema": CarDescription.model_json_schema()
    }
}

response = client.invoke_model(
    modelId='your-model-arn',
    body=json.dumps(payload),
    accept='application/json',
    contentType='application/json'
)

response_body = json.loads(response['body'].read())

Beispielantwort:

{
    "generation": "{\n    \"brand\": \"Ferrari\",\n    \"model\": \"F40\",\n    \"car_type\": \"SUV\"\n  }",
    "prompt_token_count": 22,
    "generation_token_count": 30,
    "stop_reason": "stop",
    "logprobs": null
}

OpenAICompletion

Open AICompletion unterstützt sowohl die Parameter response_format (json_object, json_schema) als auch structured_outputs (json, regex, choice, grammar). Verwenden Sie anstelle von, um Anfragen max_tokens an Open weiterzuleiten. max_gen_len AICompletion

Beispiel: Strukturierte Ausgaben — Auswahl

payload = {
    "prompt": "Classify the sentiment of this sentence. Amazon Bedrock CMI is Amazing!",
    "max_tokens": 10,
    "structured_outputs": {
        "choice": ["positive", "negative"]
    }
}

response = client.invoke_model(
    modelId='your-model-arn',
    body=json.dumps(payload),
    accept='application/json',
    contentType='application/json'
)

response_body = json.loads(response['body'].read())

Beispielantwort:

{
    "id": "cmpl-01f94c4652d24870bbb4d5418a01c384",
    "object": "text_completion",
    "choices": [
        {
            "index": 0,
            "text": "positive",
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 17,
        "completion_tokens": 4
    }
}

OpenAIChatCompletion

Open AIChat Completion unterstützt sowohl die response_format Parameter (json_object, json_schema) als auch structured_outputs (json, regex, choice, grammar).

Beispiel: Antwortformat — JSON-Schema

payload = {
    "messages": [
        {"role": "user", "content": "Generate a JSON with the brand, model and car_type of the most iconic car from the 90's"}
    ],
    "max_tokens": 100,
    "response_format": {
        "type": "json_schema",
        "json_schema": {
            "name": "car-description",
            "schema": CarDescription.model_json_schema()
        }
    }
}

response = client.invoke_model(
    modelId='your-model-arn',
    body=json.dumps(payload),
    accept='application/json',
    contentType='application/json'
)

response_body = json.loads(response['body'].read())

Beispielantwort:

{
    "id": "chatcmpl-cae5a43b0a924b8eb434510cbf978a19",
    "object": "chat.completion",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "{\"brand\": \"Dodge\", \"model\": \"Viper\", \"car_type\": \"Coupe\"}"
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 56,
        "completion_tokens": 23
    }
}

Support für das Sehvermögen

Die Bildverarbeitungsfunktionen ermöglichen die Verarbeitung von Bildern zusammen mit Texteingaben und bieten eine verbesserte Unterstützung mehrerer Bilder für komplexe visuelle Analyseaufgaben. Der Import benutzerdefinierter Modelle unterstützt jetzt bis zu 3 Bilder pro Anfrage, was gegenüber der bisherigen Beschränkung auf Einzelbilder verbessert wurde.

Unterstützte API: Nur Open AIChat Completion. Alle Modelle, die nach dem 11. November 2025 importiert wurden, verwenden standardmäßig diese API für Bildverarbeitungsfunktionen.

Anforderungen an das Bild:

• Base64-Kodierung erforderlich — Das Bild URLs führt zu Anforderungsfehlern

• Maximal 3 Bilder pro Anfrage

• Bilder mit hoher Auflösung erhöhen die Verarbeitungszeit und den Speicherverbrauch erheblich

Warnung

Bilder mit hoher Auflösung erhöhen die Verarbeitungszeit und den Speicherverbrauch erheblich und können zu Timeoutfehlern führen. Mehrere Bilder mit hoher Auflösung erhöhen die Leistungsauswirkungen exponentiell. Um eine optimale Leistung zu erzielen, sollten Sie die Bildgröße entsprechend anpassen und wenn möglich niedrigere Detailstufen verwenden.

OpenAIChatCompletion

Beispiel: Verarbeitung mehrerer Bilder

import json
import boto3
import base64

client = boto3.client('bedrock-runtime', region_name='us-east-1')

# Load and encode images
with open('/path/to/car_image_1.jpg', 'rb') as f:
    image_data_1 = base64.b64encode(f.read()).decode('utf-8')

with open('/path/to/car_image_2.jpg', 'rb') as f:
    image_data_2 = base64.b64encode(f.read()).decode('utf-8')

payload = {
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that can analyze images."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Spot the difference between the two images?"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{image_data_1}"
                    }
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{image_data_2}"
                    }
                }
            ]
        }
    ],
    "max_tokens": 300,
    "temperature": 0.5
}

response = client.invoke_model(
    modelId='your-model-arn',
    body=json.dumps(payload),
    accept='application/json',
    contentType='application/json'
)

response_body = json.loads(response['body'].read())

Beispielantwort:

{
    "id": "chatcmpl-ccae8a67e62f4014a9ffcbedfff96f44",
    "object": "chat.completion",
    "created": 1763167018,
    "model": "667387627229-g6vkuhd609s4",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "There are no differences between the two images provided. They appear to be identical.",
                "refusal": null,
                "annotations": null,
                "audio": null,
                "function_call": null,
                "tool_calls": [],
                "reasoning_content": null
            },
            "logprobs": null,
            "finish_reason": "stop",
            "stop_reason": null,
            "token_ids": null
        }
    ],
    "service_tier": null,
    "system_fingerprint": null,
    "usage": {
        "prompt_tokens": 2795,
        "total_tokens": 2812,
        "completion_tokens": 17,
        "prompt_tokens_details": null
    },
    "prompt_logprobs": null,
    "prompt_token_ids": null,
    "kv_transfer_params": null
}

Wahrscheinlichkeiten protokollieren

Logarithmische Wahrscheinlichkeiten stellen die Wahrscheinlichkeit jedes Tokens in einer Sequenz dar, berechnet als log (p), wobei p die Wahrscheinlichkeit ist, dass sich ein Token an einer beliebigen Position aufgrund seines vorherigen Tokens im Kontext befindet. Da Log-Probs additiv sind, entspricht die Sequenzwahrscheinlichkeit der Summe der einzelnen Token-Log-Probs, was sie nützlich macht, um Generationen anhand der durchschnittlichen Punktzahlen pro Token zu ordnen. Der benutzerdefinierte Modellimport gibt immer die Logprob-Rohwerte für die angeforderten Token zurück.

Zu den wichtigsten Anwendungen gehören Klassifizierungsaufgaben, bei denen Log-Probs benutzerdefinierte Konfidenzschwellen ermöglichen, Frage-und-Antwort-Systeme zum Abrufen, die Konfidenzwerte verwenden, um Halluzinationen zu reduzieren, Vorschläge zur automatischen Vervollständigung auf der Grundlage der Token-Wahrscheinlichkeit und Ratlosigkeitsberechnungen zum Vergleich der Modellleistung verschiedener Eingabeaufforderungen. Log Probs bieten auch Analysefunktionen auf Token-Ebene, sodass Entwickler alternative Tokens untersuchen können, die das Modell in Betracht gezogen hat.

Anmerkung

Logprobs werden nicht zwischengespeichert. Bei einer Anfrage, die Eingabeaufforderungs-Logprobs erfordert, ignoriert das System den Präfix-Cache und berechnet die Vorausfüllung der vollständigen Eingabeaufforderung erneut, um die Logprobs zu generieren. Dies stellt bei der Verwendung von Logprobs einen offensichtlichen Leistungsverlust dar.

Die Unterstützung von Log-Wahrscheinlichkeiten variiert je nach API-Format:

• BedrockCompletion - Nur Ausgabe-Tokens

• Öffnen AICompletion — Eingabeaufforderung und Ausgabe von Tokens

• AIChatAbschluss öffnen — Eingabeaufforderung und Ausgabe von Tokens

BedrockCompletion

BedrockCompletion unterstützt nur Logprobs für Ausgabetokens. Dadurch wird für jedes Ausgabetoken die ersten Logprob-Einträge zurückgegeben.

payload = {
    "prompt": "How is the rainbow formed?",
    "max_gen_len": 10,
    "temperature": 0.5,
    "return_logprobs": True
}

response = client.invoke_model(
    modelId='your-model-arn',
    body=json.dumps(payload),
    accept='application/json',
    contentType='application/json'
)

response_body = json.loads(response['body'].read())

Beispielantwort (gekürzt):

{
    "generation": " A rainbow is formed when sunlight passes through water dro",
    "prompt_token_count": 7,
    "generation_token_count": 10,
    "stop_reason": "length",
    "logprobs": [
        {
            "362": -2.1413702964782715
        },
        {
            "48713": -0.8180374503135681
        },
        {
            "374": -0.09657637774944305
        },
        ...
    ]
}

OpenAIChatCompletion

Open AIChat Completion unterstützt sowohl Eingabeaufforderung- als auch Ausgabetoken-Logprobs. Sie können top_logprobs=N und angebenprompt_logprobs=N, wobei N eine Ganzzahl ist, die die Log-Wahrscheinlichkeiten für die N wahrscheinlichsten Token an jeder Position darstellt.

payload = {
    "messages": [
        {
            "role": "user",
            "content": "How is the rainbow formed?"
        }
    ],
    "max_tokens": 10,
    "temperature": 0.5,
    "logprobs": True,
    "top_logprobs": 1,
    "prompt_logprobs": 1
}

response = client.invoke_model(
    modelId='your-model-arn',
    body=json.dumps(payload),
    accept='application/json',
    contentType='application/json'
)

response_body = json.loads(response['body'].read())

Beispiel für eine Antwort (gekürzt):

{
    "id": "chatcmpl-xxx",
    "object": "chat.completion",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "A rainbow is formed..."
            },
            "logprobs": {
                "content": [
                    {
                        "token": "A",
                        "logprob": -0.07903262227773666,
                        "bytes": [65],
                        "top_logprobs": [
                            {
                                "token": "A",
                                "logprob": -0.07903262227773666,
                                "bytes": [65]
                            }
                        ]
                    },
                    {
                        "token": " rainbow",
                        "logprob": -0.20187227427959442,
                        "bytes": [32, 114, 97, 105, 110, 98, 111, 119],
                        "top_logprobs": [...]
                    },
                    ...
                ]
            },
            "finish_reason": "length"
        }
    ],
    "usage": {
        "prompt_tokens": 41,
        "completion_tokens": 10,
        "total_tokens": 51
    }
}