As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Envie uma única solicitação com InvokeModel
Você executa a inferência em um único prompt usando as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)e da [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API e especificando um modelo. Há diferenças nos modelos do Amazon Bedrock com relação a se aceitam entradas de texto, imagem ou vídeo e se podem produzir saídas de texto, imagem ou incorporações. Alguns modelos podem exibir a resposta em um fluxo. Para verificar se o modelo permite entrada, saída e streaming, execute um destes procedimentos:
+ Verifique o valor nas colunas **Modalidades de entrada**, **Modalidades de saída** ou **Suporte a streaming** referentes a um modelo em [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
+ Envie uma [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)solicitação com o ID do modelo e verifique os valores no `responseStreamingSupported` campo `inputModalities``outputModalities`, e.
Execute a inferência do modelo em um prompt enviando uma [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)solicitação [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)or com um endpoint de tempo de [execução do Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt).
**nota**
As restrições se aplicam às seguintes operações: `InvokeModel` `InvokeModelWithResponseStream``Converse`,, `ConverseStream` e. Consulte as [restrições da API](inference-api-restrictions.md) para obter detalhes.
Os seguintes campos são obrigatórios:
****
| Campo | Caso de uso |
| --- | --- |
| modelId | Para especificar o modelo, o perfil de inferência ou o prompt no Gerenciamento de Prompts a ser usado. Para saber como encontrar esse valor, consulte [Enviar prompts e gerar respostas usando a API](inference-api.md). |
| body | Especificar os parâmetros de inferência para um modelo. Para consultar os parâmetros de inferência para diversos modelos, consulte[Parâmetros de solicitação de inferência e campos de resposta para modelos de base](model-parameters.md). Se você especificar uma solicitação no Gerenciamento de Prompts no campo modelId, omita esse campo (se você incluí-lo, ele será ignorado). |
Os seguintes campos são opcionais:
****
| Campo | Caso de uso |
| --- | --- |
| aceitar | Especificar o tipo de mídia para o corpo da solicitação. Para obter mais informações, consulte Media Types no [site do Swagger](https://swagger.io/specification/). |
| contentType | Especificar o tipo de mídia para o corpo da resposta. Para obter mais informações, consulte Media Types no [site do Swagger](https://swagger.io/specification/). |
| performanceConfigLatency | Para especificar se um modelo deve ser otimizado para latência. Para obter mais informações, consulte [Otimizar a inferência do modelo para latência](latency-optimized-inference.md). |
| guardrailIdentifier | Especificar uma barreira de proteção a ser aplicada ao prompt e à resposta. Para obter mais informações, consulte [Testar uma barreira de proteção](guardrails-test.md). |
| guardrailVersion | Especificar uma barreira de proteção a ser aplicada ao prompt e à resposta. Para obter mais informações, consulte [Testar uma barreira de proteção](guardrails-test.md). |
| trace | Especificar se o rastreamento da barreira de proteção especificada deve ser retornado. Para obter mais informações, consulte [Testar uma barreira de proteção](guardrails-test.md). |
| Nível de serviço | Para especificar o nível de serviço para uma solicitação. Para obter mais informações, consulte [Níveis de serviço para otimizar o desempenho e o custo](service-tiers-inference.md). |
## Exemplos de código de invocação de modelos
Este tópico fornece alguns exemplos básicos para executar inferência usando um único prompt com a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Para ver mais exemplos com modelos diferentes, acesse os seguintes recursos:
+ Escolha um exemplo abaixo do tópico [Exemplos de código para o Amazon Bedrock Runtime usando AWS SDKs](service_code_examples_bedrock-runtime.md).
+ Acesse a referência de parâmetros de inferência do modelo desejado em [Parâmetros de solicitação de inferência e campos de resposta para modelos de base](model-parameters.md).
Os exemplos a seguir pressupõem que você configurou o acesso programático para se autenticar automaticamente no AWS CLI e no SDK for Python (Boto3) em um padrão ao executar esses exemplos. Região da AWS Para ter informações sobre como configurar o acesso de programação, consulte [Começar a usar a API](getting-started-api.md).
**nota**
Analise os seguintes pontos antes de experimentar os exemplos:
Teste esses exemplos no Leste dos EUA (Norte da Virgínia) (us-east-1), que aceita todos os modelos usados nos exemplos.
O parâmetro `body` pode ser grande, então, para alguns exemplos da CLI, você deverá criar um arquivo JSON e fornecer esse arquivo no argumento `--body` em vez de especificá-lo na linha de comandos.
Nos exemplos de imagens e vídeos, você deverá usar sua própria imagem e vídeo. Os exemplos pressupõem que seu arquivo de imagem tenha um nome *image.png* e que seu arquivo de vídeo tenha um nome*video.mp4*.
Talvez seja necessário converter imagens ou vídeos em uma string codificada em base64 ou enviá-los a um local do Amazon S3. Nos exemplos, você precisará substituir os espaços reservados pela string real codificada em base64 ou pela localização do S3.
Expanda uma seção para experimentar alguns exemplos básicos de código.
### Gerar texto com um prompt de texto
Os exemplos a seguir geram uma resposta de texto a um prompt de texto usando o modelo Amazon Titan Text Premier. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Execute o comando a seguir em um terminal e encontre a resposta gerada em um arquivo chamado*invoke-model-output.txt*.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-text-premier-v1:0 \
--body '{
"inputText": "Describe the purpose of a 'hello world' program in one line.",
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5
}
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Execute o seguinte exemplo de código Python para gerar uma resposta textual:
```
# Use the native inference API to send a text message to Amazon Titan Text.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Text Premier.
model_id = "amazon.titan-text-premier-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"inputText": prompt,
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["results"][0]["outputText"]
print(response_text)
```
------
### Gere texto com um prompt de texto usando o nível de serviço
Os exemplos a seguir geram uma resposta de texto para uma solicitação de texto usando o modelo OpenAI GPT com uma camada de serviço para priorizar a solicitação. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Execute o comando a seguir em um terminal e valide o nível de serviço na resposta.
```
aws bedrock-runtime invoke-model \
--model-id openai.gpt-oss-120b-1:0 \
--body '{
"messages": [
{
"role": "user",
"content": "Describe the purpose of a '\''hello world'\'' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
}' \
--content-type application/json \
--accept application/json \
--service-tier priority \
--cli-binary-format raw-in-base64-out
```
------
#### [ Python ]
Execute o exemplo de código Python a seguir para gerar uma resposta de texto com nível de serviço:
```
import boto3
import json
# Create a Bedrock Runtime client
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1"
)
# Define the model ID and request body
model_id = "openai.gpt-oss-120b-1:0"
body = json.dumps({
"messages": [
{
"role": "user",
"content": "Describe the purpose of a 'hello world' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
})
# Make the request with service tier
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=body,
contentType="application/json",
accept="application/json",
serviceTier="priority"
)
# Parse and print the response
response_body = json.loads(response["body"])
print(response_body)
```
------
### Gere uma imagem com um prompt de texto.
Os exemplos de código a seguir geram uma imagem usando um prompt de texto com o modelo Stable Diffusion XL 1.0. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Execute o comando a seguir em um terminal e encontre a resposta gerada em um arquivo chamado*invoke-model-output.txt*. Os bytes que representam a imagem podem ser encontrados no campo `base64` da resposta:
```
aws bedrock-runtime invoke-model \
--model-id stability.stable-diffusion-xl-v1 \
--body '{
"text_prompts": [{"text": "A stylized picture of a cute old steampunk robot."}],
"style_preset": "photographic",
"seed": 0,
"cfg_scale": 10,
"steps": 30
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Execute o exemplo de código Python a seguir para gerar uma imagem e encontrar o arquivo de *stability\$11.png* imagem resultante em uma pasta chamada. *output*
```
# Use the native inference API to create an image with Amazon Titan Image Generator
import base64
import boto3
import json
import os
import random
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Image Generator G1.
model_id = "amazon.titan-image-generator-v2:0"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed.
seed = random.randint(0, 2147483647)
# Format the request payload using the model's native structure.
native_request = {
"taskType": "TEXT_IMAGE",
"textToImageParams": {"text": prompt},
"imageGenerationConfig": {
"numberOfImages": 1,
"quality": "standard",
"cfgScale": 8.0,
"height": 512,
"width": 512,
"seed": seed,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["images"][0]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"titan_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"titan_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
------
### Gerar incorporações com base no texto
Os exemplos a seguir usam o modelo Amazon Titan Text Embeddings V2 para gerar incorporações binárias para uma entrada de texto. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Execute o comando a seguir em um terminal e encontre a resposta gerada em um arquivo chamado*invoke-model-output.txt*. As incorporações resultantes estão no campo `binary`.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-text-v2:0 \
--body '{
"inputText": "What are the different services that you offer?",
"embeddingTypes": ["binary"]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Execute o seguinte exemplo de código Python para gerar incorporações para o texto fornecido:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embedding(model_id, body):
"""
Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embedding created by the model and the number of input tokens.
"""
logger.info("Generating an embedding with Amazon Titan Text Embeddings V2 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Amazon Titan Embeddings V2 - Text example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.titan-embed-text-v2:0"
input_text = "What are the different services that you offer?"
# Create request body.
body = json.dumps({
"inputText": input_text,
"embeddingTypes": ["binary"]
})
try:
response = generate_embedding(model_id, body)
print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
print(f"Input text: {input_text}")
print(f"Input Token count: {response['inputTextTokenCount']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### Gerar incorporações com base em uma imagem
Os exemplos a seguir usam o modelo Amazon Titan Multimodal Embeddings G1 para gerar incorporações para uma entrada de imagem. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Abra um novo terminal e faça o seguinte:
1. Converta uma imagem intitulada *image.png* em sua pasta atual em uma string codificada em base64 e grave-a em um arquivo intitulado *image.txt* executando o seguinte comando:
```
base64 -i image.png -o image.txt
```
1. Crie um arquivo JSON chamado *image-input-embeddings-output.json* e cole o seguinte JSON, *\$1\$1image-base64\$1* substituindo-o pelo conteúdo do *image.txt* arquivo (certifique-se de que não haja uma nova linha no final da string):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Execute o comando a seguir, especificando o *image-input-embeddings-output.json* arquivo como corpo.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-image-v1 \
--body file://image-input-embeddings-output.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Encontre as incorporações resultantes no *invoke-model-output.txt* arquivo.
------
#### [ Python ]
No script Python a seguir, */path/to/image* substitua pelo caminho para uma imagem real. Em seguida, execute o script para gerar incorporações:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from an image with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""
import base64
import json
import logging
import boto3
from botocore.exceptions import ClientError
class EmbedError(Exception):
"Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embeddings(model_id, body):
"""
Generate a vector of embeddings for an image input using Amazon Titan Multimodal Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embeddings that the model generated, token information, and the
reason the model stopped generating embeddings.
"""
logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
finish_reason = response_body.get("message")
if finish_reason is not None:
raise EmbedError(f"Embeddings generation error: {finish_reason}")
return response_body
def main():
"""
Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
model_id = 'amazon.titan-embed-image-v1'
output_embedding_length = 256
# Create request body.
body = json.dumps({
"inputImage": input_image,
"embeddingConfig": {
"outputEmbeddingLength": output_embedding_length
}
})
try:
response = generate_embeddings(model_id, body)
print(f"Generated image embeddings of length {output_embedding_length}: {response['embedding']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except EmbedError as err:
logger.error(err.message)
print(err.message)
else:
print(f"Finished generating image embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### Gerar uma resposta de texto para uma imagem com um prompt de texto anexado
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
O exemplo a seguir usa o modelo Claude 3 Haiku da Anthropic para gerar uma resposta, com uma imagem e um prompt de texto que pergunta qual é o conteúdo da imagem. Abra um novo terminal e faça o seguinte:
1. Converta uma imagem intitulada *image.png* em sua pasta atual em uma string codificada em base64 e grave-a em um arquivo intitulado *image.txt* executando o seguinte comando:
```
base64 -i image.png -o image.txt
```
1. Crie um arquivo JSON chamado *image-text-input.json* e cole o seguinte JSON, *\$1\$1image-base64\$1* substituindo-o pelo conteúdo do *image.txt* arquivo (certifique-se de que não haja uma nova linha no final da string):
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1000,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "${image-base64}"
}
},
{
"type": "text",
"text": "What's in this image?"
}
]
}
]
}
```
1. Execute o comando a seguir para gerar uma saída de texto, com base na imagem e no prompt de texto que a acompanha, para um arquivo chamado*invoke-model-output.txt*:
```
aws bedrock-runtime invoke-model \
--model-id anthropic.claude-3-haiku-20240307-v1:0 \
--body file://image-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Encontre a saída no *invoke-model-output.txt* arquivo na pasta atual.
------
#### [ Python ]
No script python a seguir, */path/to/image.png* substitua pelo caminho real da imagem antes de executar o script:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
------
### Gerar uma resposta de texto para um vídeo enviado ao Amazon S3 com um prompt de texto que o acompanha
Os exemplos a seguir mostram como gerar uma resposta com o modelo Amazon Nova Lite, considerando um vídeo que você carrega em um bucket do S3 e um prompt de texto que o acompanha.
**Pré-requisito:** faça upload de um vídeo intitulado *video.mp4* para um bucket do Amazon S3 em sua conta seguindo as etapas em [Carregar objetos no](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) Guia do usuário do Amazon Simple Storage Service. Anote o URI do S3 do vídeo.
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Abra um terminal e execute o seguinte comando, *s3://amzn-s3-demo-bucket/video.mp4* substituindo-o pela localização real do seu vídeo no S3:
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body '{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video.mp4"
}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
Encontre a saída no *invoke-model-output.txt* arquivo na pasta atual.
------
#### [ Python ]
No script Python a seguir, *s3://amzn-s3-demo-bucket/video.mp4* substitua pela localização real do seu vídeo no S3. Em seguida, execute o script:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video_s3_uri = "s3://amzn-s3-demo-bucket/video.mp4" # Replace with real S3 URI
video_ext = input_video_s3_uri.split(".")[-1]
input_text = "What happens in this video?"
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"s3Location": {
"uri": input_video_s3_uri
}
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
### Gerar uma resposta de texto para um vídeo convertido em uma string codificada em base64 com um prompt de texto que o acompanha
Os exemplos a seguir mostram como gerar uma resposta com o modelo Amazon Nova Lite, considerando um vídeo convertido em uma string codificada em base64 e um prompt de texto que o acompanha. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ CLI ]
Faça o seguinte:
1. Converta um vídeo intitulado *video.mp4* em sua pasta atual em base64 executando o seguinte comando:
```
base64 -i video.mp4 -o video.txt
```
1. Crie um arquivo JSON chamado *video-text-input.json* e cole o seguinte JSON, *\$1\$1video-base64\$1* substituindo-o pelo conteúdo do `video.txt` arquivo (certifique-se de que não haja uma nova linha no final):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Execute o comando a seguir para gerar uma saída de texto com base no vídeo e no prompt de texto que o acompanha para um arquivo chamado*invoke-model-output.txt*:
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body file://video-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Encontre a saída no *invoke-model-output.txt* arquivo na pasta atual.
------
#### [ Python ]
No script Python a seguir, */path/to/video.mp4* substitua pelo caminho real do vídeo. Em seguida, execute o script:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video = "/path/to/video.mp4" # Replace with real path to video
video_ext = input_video.split(".")[-1]
input_text = "What happens in this video?"
# Read reference video from file and encode as base64 string.
with open(input_video, "rb") as video_file:
content_video = base64.b64encode(video_file.read()).decode('utf8')\
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"bytes": content_video
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
## Exemplo de código de invocação de modelos com streaming
**nota**
O AWS CLI não suporta streaming.
O exemplo a seguir mostra como usar a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API para gerar streaming de texto com Python usando o prompt. *write an essay for living on mars in 1000 words*
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```