Saídas estruturadas Vision Support Probabilidades de registro

Recursos avançados de API para modelos importados

Esta página fornece exemplos detalhados de recursos avançados disponíveis para modelos importados após 11 de novembro de 2025. Esses recursos incluem saídas estruturadas para geração controlada, suporte de visão aprimorado para processamento de várias imagens, probabilidades de registro para insights de confiança e solicitação de ferramentas para modelos. GPT-OSS

Saídas estruturadas

As saídas estruturadas permitem a geração controlada seguindo formatos, esquemas ou padrões específicos. Esse recurso garante que a resposta do modelo atenda às restrições predefinidas, tornando-o ideal para aplicativos que exigem formatos de dados consistentes, integrações de API ou pipelines de processamento automatizados.

As saídas estruturadas na importação de modelo personalizado são suportadas por meio de dois parâmetros:

response_format- Suportes json_object e json_schema tipos
structured_outputs- Suportes jsonregex,choice, e grammar tipos

nota

Ao usar saídas estruturadas na importação de modelos personalizados, os clientes devem esperar compensações de desempenho devido à validação de restrições durante a geração. Restrições simples como choice e json_object têm impacto mínimo, enquanto restrições complexas aumentam significativamente a latência json_schema e grammar reduzem a produtividade. Para um desempenho ideal, use tipos de restrição mais simples quando possível e mantenha os esquemas simples em vez de profundamente aninhados.

Os exemplos a seguir demonstram suporte a saídas estruturadas em diferentes formatos de API. A definição do modelo Pydantic é:


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 suporta saídas estruturadas usando somente o response_format parâmetro com json_object e json_schema tipos.

Exemplo: esquema 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())

Exemplo de resposta:


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

AICompletion O Open suporta os parâmetros response_format (json_object, json_schema) e structured_outputs (json, regex, choice, grammar). Use max_tokens em vez de max_gen_len para encaminhar solicitações para AbrirAICompletion.

Exemplo: Saídas estruturadas - Escolha


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

Exemplo de resposta:


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

OpenAIChatCompletion

O Open AIChat Completion suporta os response_format parâmetros (json_object, json_schema) e structured_outputs (json, regex, choice, grammar).

Exemplo: Formato de resposta - Esquema 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())

Exemplo de resposta:


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

Vision Support

Os recursos de visão permitem o processamento de imagens junto com entradas de texto, com suporte aprimorado a várias imagens para tarefas complexas de análise visual. A importação de modelo personalizado agora suporta até 3 imagens por solicitação, aprimorada em relação à limitação anterior de uma única imagem.

API suportada: somente AIChat conclusão aberta. Todos os modelos importados após 11 de novembro de 2025 usarão como padrão essa API para recursos de visão.

Requisitos de imagem:

Codificação Base64 necessária - a imagem URLs causará falhas na solicitação
Máximo de 3 imagens por solicitação
Imagens de alta resolução aumentam significativamente o tempo de processamento e o uso da memória

Atenção

Imagens de alta resolução aumentam significativamente o tempo de processamento, o uso da memória e podem causar erros de tempo limite. Várias imagens de alta resolução aumentam o impacto exponencial no desempenho. Para um desempenho ideal, redimensione as imagens adequadamente e use níveis de detalhes mais baixos quando possível.

OpenAIChatCompletion

Exemplo: processamento de várias imagens


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

Exemplo de resposta:


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

Probabilidades de registro

As probabilidades de log representam a probabilidade de cada token em uma sequência, calculada como log (p), onde p é a probabilidade de um token em qualquer posição, considerando seu token anterior no contexto. Como os testes de log são aditivos, a probabilidade de sequência é igual à soma dos testes de log de token individuais, tornando-os úteis para classificar gerações por pontuação média por token. A importação de modelo personalizado sempre retornará os valores brutos do logprob para os tokens solicitados.

As principais aplicações incluem tarefas de classificação em que sondas de registro permitem limites de confiança personalizados, sistemas de perguntas e respostas de recuperação que usam pontuações de confiança para reduzir alucinações, sugestões de preenchimento automático com base na probabilidade simbólica e cálculos de perplexidade para comparar o desempenho do modelo entre os prompts. Os testes de log também fornecem recursos de análise em nível de token, permitindo que os desenvolvedores examinem tokens alternativos considerados pelo modelo.

nota

Os logprobs não são armazenados em cache. Para uma solicitação que exija probs de log imediatos, o sistema ignorará o cache de prefixo e recalculará o pré-preenchimento do prompt completo para gerar os logprobs. Isso apresenta uma desvantagem óbvia de desempenho ao usar logprobs.

O suporte à probabilidade de log varia de acordo com o formato da API:

BedrockCompletion - Somente tokens de saída
Abrir AICompletion - Tokens de alerta e saída
AIChatConclusão aberta - Tokens de alerta e saída

BedrockCompletion

BedrockCompletion só suporta logprobs de token de saída. Isso retornará o primeiro logprob para cada token de saída.


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

Exemplo de resposta (truncada):


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

O Open AIChat Completion suporta probs de log de token de prompt e de saída. Você pode definir top_logprobs=N e prompt_logprobs=N onde N é um número inteiro representando probabilidades logarítmicas para os N tokens mais prováveis em cada posição.


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

Exemplo de resposta (truncada):


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Invocar o modelo importado

Modelos de bate-papo e tokenizadores personalizados