Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Envíe un único mensaje con InvokeModel
La inferencia se realiza en una sola solicitud mediante las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)y la [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API y especificando un modelo. Los modelos de Amazon Bedrock difieren en cuanto a si aceptan entradas de texto, imagen o vídeo y si pueden producir salidas de texto, imagen o incrustaciones. Algunos modelos pueden devolver la respuesta en una secuencia. Para comprobar la compatibilidad del modelo con la entrada, la salida y la transmisión, realice una de las siguientes acciones:
+ Compruebe el valor en las columnas **Modalidades de entrada**, **Modalidades de salida** o **Compatibles con la transmisión** para un modelo en [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
+ Envía una [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)solicitud con el ID del modelo y comprueba los valores del `responseStreamingSupported` campo `inputModalities``outputModalities`, y.
Ejecute la inferencia del modelo en un mensaje enviando una [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)solicitud [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)o con un punto de [ejecución de Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt).
**nota**
Se aplican restricciones a las siguientes operaciones:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, y. `ConverseStream` Consulte [las restricciones de la API](inference-api-restrictions.md) para obtener más información.
Los siguientes campos son obligatorios:
****
| Campo | Caso de uso |
| --- | --- |
| modelId | Especificar el modelo, el perfil de inferencia o la petición desde Administración de peticiones que se va a utilizar. Para obtener más información sobre cómo encontrar este valor, consulte [Envío de solicitudes y generación de respuestas mediante la API](inference-api.md). |
| cuerpo | Para especificar los parámetros de inferencia de un modelo. Para ver los parámetros de inferencia de los diferentes modelos, consulte [Parámetros de solicitud de inferencia y campos de respuesta para los modelos fundacionales](model-parameters.md). Si especifica una petición desde Administración de peticiones en el campo modelId, omita este campo (si lo incluye, se ignorará). |
Los siguientes campos son opcionales:
****
| Campo | Caso de uso |
| --- | --- |
| accept | Para especificar el tipo de soporte del cuerpo de la solicitud. Para obtener más información, consulte Media types en el [sitio web de Swagger](https://swagger.io/specification/). |
| contentType | Para especificar el tipo de soporte del cuerpo de la respuesta. Para obtener más información, consulte Media types en el [sitio web de Swagger](https://swagger.io/specification/). |
| performanceConfigLatency | Especificar si se debe optimizar un modelo para la latencia. Para obtener más información, consulte [Optimización de la inferencia del modelo para la latencia](latency-optimized-inference.md). |
| guardrailIdentifier | Para especificar una barrera de protección para aplicarla a la petición y a la respuesta. Para obtener más información, consulte [Prueba de la barrera de protección](guardrails-test.md). |
| guardrailVersion | Para especificar una barrera de protección para aplicarla a la petición y a la respuesta. Para obtener más información, consulte [Prueba de la barrera de protección](guardrails-test.md). |
| trace | Para especificar si se debe devolver el seguimiento de la barrera de protección que especifique. Para obtener más información, consulte [Prueba de la barrera de protección](guardrails-test.md). |
| ServiceTier | Para especificar el nivel de servicio de una solicitud. Para obtener más información, consulte [Niveles de servicio para optimizar el rendimiento y los costes](service-tiers-inference.md). |
## Ejemplos de código de modelo de invocación
En este tema se proporcionan algunos ejemplos básicos para ejecutar inferencias mediante una única solicitud con la [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Para ver más ejemplos con diferentes modelos, consulte los siguientes recursos:
+ Elija un ejemplo en el tema [Ejemplos de código para Amazon Bedrock Runtime mediante AWS SDKs](service_code_examples_bedrock-runtime.md).
+ Consulte la referencia del parámetro de inferencia del modelo deseado en [Parámetros de solicitud de inferencia y campos de respuesta para los modelos fundacionales](model-parameters.md).
En los ejemplos siguientes se supone que ha configurado el acceso mediante programación de forma que se autentica automáticamente en el AWS CLI SDK para Python (Boto3) de forma predeterminada al ejecutar estos ejemplos. Región de AWS Para obtener información acerca de cómo configurar el acceso mediante programación, consulte [Introducción a la API](getting-started-api.md).
**nota**
Consulte los puntos siguientes antes de probar los ejemplos:
Debe probar estos ejemplos en Este de EE. UU. (Norte de Virginia) (us-east-1), que admite todos los modelos utilizados en los ejemplos.
El parámetro `body` puede ser grande, por lo que, en algunos ejemplos de la CLI, se le pedirá que cree un archivo JSON y lo incluya en el argumento `--body` en lugar de especificarlo en la línea de comandos.
Para los ejemplos de imagen y vídeo, se le pedirá que utilice su propia imagen y vídeo. En los ejemplos se supone que el archivo de imagen tiene un nombre *image.png* y que el archivo de vídeo tiene un nombre. *video.mp4*
Puede que tenga que convertir las imágenes o vídeos en una cadena codificada en base64 o cargarlos en una ubicación de Amazon S3. En los ejemplos, tendrá que reemplazar los marcadores de posición por la cadena codificada en base64 o la ubicación en S3 reales.
Expanda una sección para probar algunos ejemplos de código básicos.
### Generación de texto con una petición de texto
Los siguientes ejemplos generan una respuesta de texto a una petición de texto utilizando el modelo Amazon Titan Text Premier. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecute el siguiente comando en una terminal y busque la respuesta generada en un archivo llamado*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 ]
Ejecute el siguiente ejemplo de código de Python para generar una respuesta de texto:
```
# 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)
```
------
### Genere texto con un mensaje de texto utilizando el nivel de servicio
Los siguientes ejemplos generan una respuesta de texto a una solicitud de texto mediante el modelo OpenAI GPT con un nivel de servicio para priorizar la solicitud. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecuta el siguiente comando en un terminal y valida el nivel de servicio en la respuesta.
```
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 ]
Ejecute el siguiente ejemplo de código de Python para generar una respuesta de texto con el nivel de servicio:
```
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)
```
------
### Generación de una imagen mediante un petición de texto
Los siguientes ejemplos de código generan una imagen mediante una petición de texto con el modelo Stable Diffusion XL 1.0. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecute el siguiente comando en una terminal y busque la respuesta generada en un archivo llamado*invoke-model-output.txt*. Los bytes que representan la imagen se encuentran en el campo `base64` de la respuesta:
```
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 ]
Ejecute el siguiente ejemplo de código de Python para generar una imagen y buscar el archivo de *stability\$11.png* imagen resultante en una carpeta llamada*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}")
```
------
### Generación de incrustaciones a partir de texto
Los siguientes ejemplos utilizan el modelo Amazon Titan Text Embeddings V2 para generar incrustaciones binarias para una entrada de texto. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecuta el siguiente comando en una terminal y busca la respuesta generada en un archivo llamado*invoke-model-output.txt*. Las incrustaciones resultantes están en el 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 ]
Ejecute el siguiente ejemplo de código de Python para generar incrustaciones para el texto proporcionado:
```
# 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()
```
------
### Generación de incrustaciones a partir de una imagen
Los siguientes ejemplos utilizan el modelo Amazon Titan Multimodal Embeddings G1 para generar incrustaciones para una entrada de imagen. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Abra una nueva ventana de terminal de la siguiente manera:
1. Convierte una imagen titulada *image.png* en tu carpeta actual en una cadena codificada en base64 y escríbela en un archivo titulado *image.txt* ejecutando el siguiente comando:
```
base64 -i image.png -o image.txt
```
1. Crea un archivo JSON llamado *image-input-embeddings-output.json* y pega el siguiente JSON y *\$1\$1image-base64\$1* sustitúyelo por el contenido del *image.txt* archivo (asegúrate de que no haya ninguna línea nueva al final de la cadena):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Ejecute el siguiente comando, especificando el *image-input-embeddings-output.json* archivo como cuerpo.
```
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. Busque las incrustaciones resultantes en el archivo. *invoke-model-output.txt*
------
#### [ Python ]
En el siguiente script de Python, */path/to/image* sustitúyalo por la ruta a una imagen real. A continuación, ejecute el script para generar incrustaciones:
```
# 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()
```
------
### Generación de una respuesta de texto a una imagen con una petición del texto que la acompaña
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
En el siguiente ejemplo, se utiliza el modelo Anthropic Claude 3 Haiku para generar una respuesta, dada una imagen y una petición de texto que pregunta por el contenido de la imagen. Abra una nueva ventana de terminal de la siguiente manera:
1. Convierte una imagen titulada *image.png* en tu carpeta actual en una cadena codificada en base64 y escríbela en un archivo titulado *image.txt* ejecutando el siguiente comando:
```
base64 -i image.png -o image.txt
```
1. Crea un archivo JSON llamado *image-text-input.json* y pega el siguiente JSON y *\$1\$1image-base64\$1* sustitúyelo por el contenido del *image.txt* archivo (asegúrate de que no haya ninguna línea nueva al final de la cadena):
```
{
"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. Ejecute el siguiente comando para generar una salida de texto, basada en la imagen y el mensaje de texto que la acompaña, en un archivo llamado*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. Busca el resultado en el *invoke-model-output.txt* archivo de la carpeta actual.
------
#### [ Python ]
En el siguiente script de Python, */path/to/image.png* sustitúyalo por la ruta real a la imagen antes de ejecutar el 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()
```
------
### Generación de una respuesta de texto a un vídeo cargado en Amazon S3 con una petición del texto que lo acompaña
Los siguientes ejemplos muestran cómo generar una respuesta con el modelo Amazon Nova Lite, dado un vídeo que se carga en un bucket de S3 y la petición del texto que lo acompaña.
**Requisito previo:** Suba un vídeo titulado *video.mp4* a un bucket de Amazon S3 de su cuenta siguiendo los pasos que se indican en [Carga de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) en la Guía del usuario de Amazon Simple Storage Service. Anote la URI de S3 del video.
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Abre una terminal y ejecuta el siguiente comando, sustituyéndola por *s3://amzn-s3-demo-bucket/video.mp4* la ubicación real de tu vídeo en 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
```
Busca el resultado en el *invoke-model-output.txt* archivo de la carpeta actual.
------
#### [ Python ]
En la siguiente secuencia de comandos de Python, *s3://amzn-s3-demo-bucket/video.mp4* sustitúyala por la ubicación S3 real del vídeo. A continuación, ejecute el 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()
```
------
### Generación de una respuesta de texto a un vídeo convertido en una cadena codificada en base64 con una petición del texto que lo acompaña
Los siguientes ejemplos muestran cómo generar una respuesta con el modelo Amazon Nova Lite, dado un vídeo convertido en una cadena codificada en base64 y la petición del texto que lo acompaña. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Haga lo siguiente:
1. Convierte un vídeo titulado *video.mp4* en tu carpeta actual a base64 ejecutando el siguiente comando:
```
base64 -i video.mp4 -o video.txt
```
1. Crea un archivo JSON llamado *video-text-input.json* y pega el siguiente JSON, *\$1\$1video-base64\$1* sustituyéndolo por el contenido del `video.txt` archivo (asegúrate de que no haya ninguna línea nueva al final):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Ejecute el siguiente comando para generar una salida de texto basada en el vídeo y el mensaje de texto que lo acompaña en un archivo llamado*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. Busca el resultado en el *invoke-model-output.txt* archivo de la carpeta actual.
------
#### [ Python ]
En la siguiente secuencia de comandos de Python, */path/to/video.mp4* sustitúyala por la ruta real al vídeo. A continuación, ejecute el 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()
```
------
## Ejemplos de código de modelo de invocación con transmisión
**nota**
AWS CLI No es compatible con la transmisión.
El siguiente ejemplo muestra cómo usar la [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API para generar texto en streaming con Python mediante la línea de comandos*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()))
```