Esempi di codice per la personalizzazione del modello

Innanzitutto, crea un file di testo denominato. FineTuningData.json Copia il codice JSON dal basso nel file di testo, sostituendo ${training-bucket} e ${output-bucket} con i nomi dei bucket S3.

{
    "trainingDataConfig": {
        "s3Uri": "s3://${training-bucket}/train.jsonl"
    },
    "outputDataConfig": {
        "s3Uri": "s3://${output-bucket}"
    }
}

Per inviare un lavoro di personalizzazione del modello, accedi alla cartella contenuta FineTuningData.json in un terminale ed esegui il seguente comando nella riga di comando, sostituendolo ${your-customization-role-arn} con il ruolo di personalizzazione del modello che hai impostato.

aws bedrock create-model-customization-job \
    --customization-type FINE_TUNING \
    --base-model-identifier arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-text-express-v1 \
    --role-arn ${your-customization-role-arn} \
    --job-name MyFineTuningJob \
    --custom-model-name MyCustomModel \
    --hyper-parameters epochCount=1,batchSize=1,learningRate=.0001,learningRateWarmupSteps=0 \
    --cli-input-json file://FineTuningData.json
                

La risposta restituisce un jobArn. Attendi il completamento del processo. Puoi verificarne lo stato con il seguente comando.

aws bedrock get-model-customization-job \
    --job-identifier "jobArn"

Quando lo status è COMPLETE, puoi visualizzare le trainingMetrics nella risposta. È possibile scaricare gli artefatti nella cartella corrente eseguendo il comando seguente, sostituendolo aet.et-bucket con il nome del bucket di output e jobId con l'ID del processo di personalizzazione (la sequenza che segue l'ultima barra del). jobArn

aws s3 cp s3://${output-bucket}/model-customization-job-jobId . --recursive

Acquista uno throughput assegnato senza impegno per il tuo modello personalizzato con il seguente comando.

aws bedrock create-provisioned-model-throughput \
    --model-id MyCustomModel \
    --provisioned-model-name MyProvisionedCustomModel \
    --model-units 1

La risposta restituisce un provisionedModelArn. Attendi un po’ di tempo per la creazione dello throughput assegnato. Per verificarne lo stato, fornisci il nome o l’ARN del modello assegnato come il provisioned-model-id nel seguente comando.

aws bedrock get-provisioned-model-throughput \
    --provisioned-model-id ${provisioned-model-arn}

Quando lo status è InService, puoi eseguire l’inferenza con il tuo modello personalizzato con il seguente comando. Devi fornire l’ARN del modello assegnato come il model-id. L'output viene scritto in un file denominato output.txt nella cartella corrente.

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

Esegui il seguente frammento di codice per inviare un processo di fine-tuning. Sostituisci ${your-customization-role-arn} con l'ARN del file MyCustomizationRole che hai impostato e sostituito ${training-bucket} e ${output-bucket} con i nomi dei tuoi bucket S3.

import boto3

bedrock = boto3.client(service_name='bedrock')
    
# Set parameters
customizationType = "FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-text-express-v1"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"
hyperParameters = {
        "epochCount": "1",
        "batchSize": "1",
        "learningRate": ".0001",
        "learningRateWarmupSteps": "0"
    }
trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}

# Create job
response_ft = bedrock.create_model_customization_job(
    jobName=jobName, 
    customModelName=customModelName,
    roleArn=roleArn,
    baseModelIdentifier=baseModelIdentifier,
    hyperParameters=hyperParameters,
    trainingDataConfig=trainingDataConfig,
    outputDataConfig=outputDataConfig
)

jobArn = response_ft.get('jobArn')

La risposta restituisce un jobArn. Attendi il completamento del processo. Puoi verificarne lo stato con il seguente comando.

bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status')

Quando lo status èCOMPLETE, puoi vederlo trainingMetrics nella risposta. GetModelCustomizationJob Puoi anche seguire la procedura descritta in Download degli oggetti per scaricare le metriche.

Acquista uno throughput assegnato senza impegno per il tuo modello personalizzato con il seguente comando.

response_pt = bedrock.create_provisioned_model_throughput(
    modelId="MyCustomModel",
    provisionedModelName="MyProvisionedCustomModel",
    modelUnits="1"
)

provisionedModelArn = response_pt.get('provisionedModelArn')

La risposta restituisce un provisionedModelArn. Attendi un po’ di tempo per la creazione dello throughput assegnato. Per verificarne lo stato, fornisci il nome o l’ARN del modello assegnato come il provisionedModelId nel seguente comando.

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

Quando lo status è InService, puoi eseguire l’inferenza con il tuo modello personalizzato con il seguente comando. Devi fornire l’ARN del modello assegnato come il modelId.

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 = provisionedModelArn

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

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