Exemples de code pour le débit provisionné

Les exemples de code suivants montrent comment créer, utiliser et gérer un débit provisionné avec AWS CLI et Python. SDK

AWS CLI

Créez un débit provisionné sans engagement appelé sur la MyPT base d'un modèle personnalisé appelé MyCustomModel qui a été personnalisé à partir du Anthropic Claude modèle v2.1 en exécutant la commande suivante dans un terminal.

aws bedrock create-provisioned-model-throughput \
   --model-units 1 \
   --provisioned-model-name MyPT \
   --model-id arn:aws:bedrock:us-east-1::custom-model/anthropic.claude-v2:1:200k/MyCustomModel

La réponse renvoie unprovisioned-model-arn. Prévoyez un peu de temps pour terminer la création. Pour vérifier son état, indiquez le nom ou ARN le modèle provisionné comme indiqué provisioned-model-id dans la commande suivante.

aws bedrock get-provisioned-model-throughput \
    --provisioned-model-id MyPT

Modifiez le nom du débit provisionné et associez-le à un autre modèle personnalisé à partir de Anthropic Claude v2.1.

aws bedrock update-provisioned-model-throughput \
    --provisioned-model-id MyPT \ 
    --desired-provisioned-model-name MyPT2 \
    --desired-model-id arn:aws:bedrock:us-east-1::custom-model/anthropic.claude-v2:1:200k/MyCustomModel2

Exécutez l'inférence avec votre modèle provisionné mis à jour à l'aide de la commande suivante. Vous devez fournir le ARN modèle provisionné, renvoyé dans la UpdateProvisionedModelThroughput réponse, sous la forme demodel-id. La sortie est écrite dans un fichier nommé output.txt dans votre dossier actuel.

aws bedrock-runtime invoke-model \
    --model-id ${provisioned-model-arn} \
    --body '{"inputText": "What is AWS?", "textGenerationConfig": {"temperature": 0.5}}' \
    --cli-binary-format raw-in-base64-out \
    output.txt

Supprimez le débit provisionné à l'aide de la commande suivante. Le débit provisionné ne vous sera plus facturé.

aws bedrock delete-provisioned-model-throughput 
  --provisioned-model-id MyPT2

Python (Boto)

Créez un débit provisionné sans engagement appelé sur la MyPT base d'un modèle personnalisé appelé MyCustomModel qui a été personnalisé à partir du Anthropic Claude modèle v2.1 en exécutant l'extrait de code suivant.

import boto3 
                    
bedrock = boto3.client(service_name='bedrock')
bedrock.create_provisioned_model_throughput(
    modelUnits=1,
    provisionedModelName='MyPT', 
    modelId='arn:aws:bedrock:us-east-1::custom-model/anthropic.claude-v2:1:200k/MyCustomModel' 
)

La réponse renvoie unprovisionedModelArn. Prévoyez un peu de temps pour terminer la création. Vous pouvez vérifier son statut à l'aide de l'extrait de code suivant. Vous pouvez fournir le nom du débit provisionné ou celui ARN renvoyé par la CreateProvisionedModelThroughputréponse sous la forme de. provisionedModelId

bedrock.get_provisioned_model_throughput(provisionedModelId='MyPT')

Modifiez le nom du débit provisionné et associez-le à un autre modèle personnalisé à partir de Anthropic Claude v2.1. Envoyez ensuite une GetProvisionedModelThroughputdemande et enregistrez le ARN modèle provisionné dans une variable à utiliser pour l'inférence.

bedrock.update_provisioned_model_throughput(
    provisionedModelId='MyPT',
    desiredProvisionedModelName='MyPT2',
    desiredModelId='arn:aws:bedrock:us-east-1::custom-model/anthropic.claude-v2:1:200k/MyCustomModel2'
)
                
arn_MyPT2 = bedrock.get_provisioned_model_throughput(provisionedModelId='MyPT2').get('provisionedModelArn')

Exécutez l'inférence avec votre modèle provisionné mis à jour à l'aide de la commande suivante. Vous devez fournir le ARN modèle provisionné en tant quemodelId.

import json
import logging
import boto3

from botocore.exceptions import ClientError


class ImageError(Exception):
    "Custom exception for errors returned by the model"

    def __init__(self, message):
        self.message = message


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text(model_id, body):
    """
    Generate text using your provisioned custom model.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (json): The response from the model.
    """

    logger.info(
        "Generating text with your provisioned custom model %s", model_id)

    brt = boto3.client(service_name='bedrock-runtime')

    accept = "application/json"
    content_type = "application/json"

    response = brt.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("error")

    if finish_reason is not None:
        raise ImageError(f"Text generation error. Error is {finish_reason}")

    logger.info(
        "Successfully generated text with provisioned custom model %s", model_id)

    return response_body


def main():
    """
    Entrypoint for example.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        model_id = arn_myPT2

        body = json.dumps({
            "inputText": "what is AWS?"
        })

        response_body = generate_text(model_id, body)
        print(f"Input token count: {response_body['inputTextTokenCount']}")

        for result in response_body['results']:
            print(f"Token count: {result['tokenCount']}")
            print(f"Output text: {result['outputText']}")
            print(f"Completion reason: {result['completionReason']}")

    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 ImageError as err:
        logger.error(err.message)
        print(err.message)

    else:
        print(
            f"Finished generating text with your provisioned custom model {model_id}.")


if __name__ == "__main__":
    main()

Supprimez le débit provisionné à l'aide de l'extrait de code suivant. Le débit provisionné ne vous sera plus facturé.

bedrock.delete_provisioned_model_throughput(provisionedModelId='MyPT2')