Creare un modello personalizzato (SDK AWS) - Amazon Bedrock

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Creare un modello personalizzato (SDK AWS)

Per creare un modello personalizzato da un modello Amazon Nova addestrato dall’IA di SageMaker e archiviato in Amazon S3, utilizzare l’operazione dell’API CreateCustomModel. È possibile utilizzare il seguente codice creare un modello personalizzato con l’SDK per Python (Boto3). Il codice crea un modello personalizzato e poi ne controlla lo stato fino a quando il modello è ACTIVE e pronto all’uso.

Per utilizzare il codice, aggiornare i seguenti parametri. L’esempio di codice include anche parametri facoltativi come clientRequestToken per l’idempotenza e modelTags per l’assegnazione di tag alle risorse.

  • modelName: assegna al modello un nome univoco.

  • s3Uri: specifica il percorso del bucket Amazon S3 gestito da Amazon che memorizza gli artefatti del modello. SageMaker AI crea questo bucket quando viene eseguito il primo job di addestramento di SageMaker AI.

  • roleArn: specifica il nome della risorsa Amazon (ARN) di un ruolo di servizio IAM che Amazon Bedrock assume per eseguire attività. Per ulteriori informazioni sulla creazione di questo ruolo, consultare Creazione di un ruolo di servizio per l’importazione di modelli pre-addestrati.

  • modelKmsKeyArn (facoltativo): specifica una chiave AWS KMS per crittografare il modello in Amazon Bedrock. Se non viene fornita una chiave AWS KMS, Amazon Bedrock utilizza una chiave AWS KMS gestita da AWS per crittografare il modello. Per informazioni sulla crittografia, consulta Crittografia di modelli personalizzati importati.

Dopo aver creato il modello personalizzato, il modello viene visualizzato nella risposta ListCustomModels con un customizationType di imported. Per tenere traccia dello stato del nuovo modello, utilizzate l’operazione dell’API GetCustomModel.

import boto3
import uuid
from botocore.exceptions import ClientError
import time

def create_custom_model(bedrock_client):
    """
    Creates a custom model in Amazon Bedrock from a SageMaker AI-trained Amazon Nova model stored in Amazon S3.
    Args:
        bedrock_client: The Amazon Bedrock client instance
    Returns:
        dict: Response from the CreateCustomModel API call
    """
    try:
        # Create a unique client request token for idempotency
        client_request_token = str(uuid.uuid4())

        # Define the model source configuration
        model_source_config = {
            's3DataSource': {
                's3Uri': 's3://amzn-s3-demo-bucket/folder/',
            }
        }

        # Create the custom model
        response = bedrock_client.create_custom_model(
            # Required parameters
            modelName='modelName',
            roleArn='serviceRoleArn',
            modelSourceConfig=model_source_config,

            # Optional parameters
            clientRequestToken=client_request_token,
            modelKmsKeyArn='keyArn',
            modelTags=[
                {
                    'key': 'Environment',
                    'value': 'Production'
                },
                {
                    'key': 'Project',
                    'value': 'AIInference'
                }
            ]
        )

        print(f"Custom model creation initiated. Model ARN: {response['modelArn']}")

        return response

    except ClientError as e:
        print(f"Error creating custom model: {e}")
        raise

def list_custom_models(bedrock_client):
    """
    Lists all custom models in Amazon Bedrock.

    Args:
        bedrock_client: An Amazon Bedrock client.

    Returns:
        dict: Response from the ListCustomModels API call

    """

    try:
        response = bedrock_client.list_custom_models()
        print(f"Total number of custom models: {len(response['modelSummaries'])}")

        for model in response['modelSummaries']:
            print("ARN: " + model['modelArn'])
            print("Name: " + model['modelName'])
            print("Status: " + model['modelStatus'])
            print("Customization type: " + model['customizationType'])
            print("------------------------------------------------------")

        return response

    except ClientError as e:
        print(f"Error listing custom models: {e}")
        raise

def check_model_status(bedrock_client, model_arn):
    """
    Checks the status of a custom model creation.

    Args:
        model_arn (str): The ARN of the custom model
        bedrock_client: An Amazon Bedrock client.

    Returns:
        dict: Response from the GetCustomModel API call

    """

    try:
        max_time = time.time() + 60 * 60  # 1 hour

        while time.time() < max_time:
            response = bedrock_client.get_custom_model(modelIdentifier=model_arn)
            status = response.get('modelStatus')
            print(f"Job status: {status}")
            if status == 'Failed':
                print(f"Failure reason: {response.get('failureMessage')}")
                break
            if status == 'Active':
                print("Model is ready for use.")
                break
            time.sleep(60)

    except ClientError as e:
        print(f"Error checking model status: {e}")
        raise


def main():
    bedrock_client = boto3.client(service_name='bedrock', region_name='REGION')
    
    # Create the custom model
    model_arn = create_custom_model(bedrock_client)["modelArn"]

    # Check the status of the model
    if model_arn:
        check_model_status(bedrock_client, model_arn)

    # View all custom models
    list_custom_models(bedrock_client)


if __name__ == "__main__":
    main()