Sorties structurées Support visuel Probabilités de journalisation

Fonctionnalités d'API avancées pour les modèles importés

Cette page fournit des exemples détaillés de fonctionnalités avancées disponibles pour les modèles importés après le 11 novembre 2025. Ces fonctionnalités incluent des sorties structurées pour une génération contrôlée, une prise en charge visuelle améliorée pour le traitement de plusieurs images, des probabilités logarithmiques pour des informations fiables et l'appel d'outils pour GPT-OSS des modèles.

Sorties structurées

Les sorties structurées permettent une génération contrôlée selon des formats, des schémas ou des modèles spécifiques. Cette fonctionnalité garantit que la réponse du modèle respecte les contraintes prédéfinies, ce qui le rend idéal pour les applications nécessitant des formats de données cohérents, des intégrations d'API ou des pipelines de traitement automatisés.

Les sorties structurées sur l'importation de modèles personnalisés sont prises en charge via deux paramètres :

response_format- Supports json_object et json_schema types
structured_outputs- Supports jsonregex,choice, et grammar types

Note

Lorsqu'ils utilisent des sorties structurées pour l'importation de modèles personnalisés, les clients doivent s'attendre à des compromis en termes de performances en raison de la validation des contraintes lors de la génération. Des contraintes simples telles que choice et json_object ont un impact minimal, tandis que json_schema des contraintes complexes grammar peuvent augmenter considérablement la latence et réduire le débit. Pour des performances optimales, utilisez des types de contraintes plus simples lorsque cela est possible et maintenez les schémas plats plutôt que profondément imbriqués.

Les exemples suivants illustrent la prise en charge des sorties structurées dans différents formats d'API. La définition du modèle pydantique est la suivante :


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 prend en charge les sorties structurées en utilisant uniquement le response_format paramètre with json_object et json_schema types.

Exemple : schéma JSON


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())

Exemple de réponse :


{
    "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 prend en charge les response_format paramètres (json_object, json_schema) et structured_outputs (json, regex, choice, grammar). À utiliser max_tokens au lieu de max_gen_len pour acheminer les demandes vers OpenAICompletion.

Exemple : Sorties structurées - Choix


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())

Exemple de réponse :


{
    "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 prend en charge les paramètres response_format (json_object, json_schema) et structured_outputs (json, regex, choice, grammar).

Exemple : format de réponse - schéma JSON


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())

Exemple de réponse :


{
    "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 visuel

Les fonctionnalités de vision permettent de traiter des images parallèlement aux entrées de texte, avec une prise en charge améliorée de plusieurs images pour les tâches d'analyse visuelle complexes. L'importation de modèles personnalisés prend désormais en charge jusqu'à 3 images par demande, ce qui constitue une amélioration par rapport à la précédente limitation à une seule image.

API prise en charge : Open AIChat Completion uniquement. Tous les modèles importés après le 11 novembre 2025 utiliseront par défaut cette API pour les fonctionnalités de vision.

Exigences relatives à l'image :

Encodage Base64 requis - L'image URLs provoquera des échecs de requête
Maximum de 3 images par demande
Les images haute résolution augmentent considérablement le temps de traitement et l'utilisation de la mémoire

Avertissement

Les images haute résolution augmentent considérablement le temps de traitement, l'utilisation de la mémoire et peuvent provoquer des erreurs de temporisation. Plusieurs images haute résolution aggravent l'impact sur les performances de manière exponentielle. Pour des performances optimales, redimensionnez les images de manière appropriée et utilisez des niveaux de détail inférieurs lorsque cela est possible.

OpenAIChatCompletion

Exemple : traitement de plusieurs images


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())

Exemple de réponse :


{
    "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
}

Probabilités de journalisation

Les probabilités logarithmiques représentent la probabilité de chaque jeton d'une séquence, calculée sous la forme log (p) où p est la probabilité d'un jeton à n'importe quelle position étant donné son jeton précédent dans le contexte. Comme les probes logarithmiques sont additives, la probabilité de séquence est égale à la somme des probes logarithmiques individuelles, ce qui les rend utiles pour classer les générations en fonction des scores moyens par jeton. L'importation de modèles personnalisés renverra toujours les valeurs brutes de logprob pour les jetons demandés.

Les principales applications incluent les tâches de classification dans lesquelles les probes de log permettent de personnaliser les seuils de confiance, les systèmes de questions-réponses qui utilisent les scores de confiance pour réduire les hallucinations, les suggestions de saisie semi-automatique basées sur la probabilité symbolique et les calculs de perplexité pour comparer les performances du modèle entre les instructions. Les log probs fournissent également des fonctionnalités d'analyse au niveau des jetons, permettant aux développeurs d'examiner les jetons alternatifs pris en compte par le modèle.

Note

Les logprobs ne sont pas mis en cache. Pour une demande nécessitant des probs de journalisation rapides, le système ignorera le cache de préfixes et recalculera le préremplissage de l'invite complète pour générer les probs de journalisation. Cela représente un compromis évident en termes de performances lors de l'utilisation de logprobs.

La prise en charge de la probabilité des logs varie selon le format de l'API :

BedrockCompletion - Jetons de sortie uniquement
Ouvert AICompletion - Jetons d'invite et de sortie
Open AIChat Completion - Jetons d'invite et de sortie

BedrockCompletion

BedrockCompletion ne prend en charge que les probs de journalisation des jetons de sortie. Cela renverra le premier logprob pour chaque jeton de sortie.


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())

Exemple de réponse (tronquée) :


{
    "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 prend en charge à la fois les probs d'invite et de jeton de sortie. Vous pouvez définir top_logprobs=N et prompt_logprobs=N où N est un entier représentant les probabilités logarithmiques pour les N jetons les plus probables à chaque position.


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())

Exemple de réponse (tronquée) :


{
    "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
    }
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Invocation du modèle importé

Modèles de chat et tokeniseurs personnalisés