Ejemplos de código de modelo de invocación Ejemplos de código de modelo de invocación con transmisión

Envíe un único mensaje con InvokeModel

La inferencia se realiza en una sola solicitud mediante las operaciones InvokeModely la InvokeModelWithResponseStreamAPI 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.
Envía una GetFoundationModelsolicitud con el ID del modelo y comprueba los valores del responseStreamingSupported campo inputModalitiesoutputModalities, y.

importante

InvokeModel e InvokeModelWithResponseStream tienen las siguientes limitaciones:

No se puede generar un vídeo con estas operaciones de API. En su lugar, debes usar la StartAsyncInvokeAPI. Para ver un ejemplo, consulte Uso de Amazon Nova Reel para generar un vídeo a partir de una petición de texto.
No se puede incluir un documento en el cuerpo de la solicitud. Para incluir un documento durante la inferencia, usa el campo de chat/texto del chat Consola de administración de AWS o envía una solicitud de Converse.

Ejecute la inferencia del modelo en un mensaje enviando una InvokeModelWithResponseStreamsolicitud InvokeModelo con un punto de ejecución de Amazon Bedrock.

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.
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. 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.
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.
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.
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.
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.
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.
Nivel de servicio	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.

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 InvokeModelAPI. 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 utilizando AWS SDKs.
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.

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.

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.

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

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:

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 llamadoinvoke-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_1.png imagen resultante en una carpeta llamadaoutput.


# 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-v1"

# 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}")

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

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:

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
```
Crea un archivo JSON llamado image-input-embeddings-output.json y pega el siguiente JSON y ${image-base64} 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
    }
}
```

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

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

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:

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
```

Crea un archivo JSON llamado image-text-input.json y pega el siguiente JSON y ${image-base64} 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?"
                }
            ]
        }
    ]
}

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 llamadoinvoke-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

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 occured: " +
              format(message))


if __name__ == "__main__":
    main()

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

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:

Convierte un vídeo titulado video.mp4 en tu carpeta actual a base64 ejecutando el siguiente comando:
```
base64 -i video.mp4 -o video.txt
```

Crea un archivo JSON llamado video-text-input.json y pega el siguiente JSON, ${video-base64} 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?"
                }
            ]
        }                              
    ]                  
}

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 llamadoinvoke-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

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 CLINo es compatible con la transmisión.

El siguiente ejemplo muestra cómo usar la InvokeModelWithResponseStreamAPI para generar texto en streaming con Python mediante la línea de comandoswrite 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()))

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Generación de respuestas mediante la API

Uso de la API Chat Completions de OpenAI