Esempi di codice per la personalizzazione del modello

Innanzitutto, crea un file di testo denominato FineTuningData.json. Copia il JSON codice dal basso nel file di testo, sostituendo ${training-bucket} e ${output-bucket} con i nomi dei tuoi 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 contenente FineTuningData.json in un terminale ed esegui il seguente comando nella riga di comando, sostituendo ${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=.0005,learningRateWarmupSteps=0 \
    --cli-input-json file://FineTuningData.json
                

La risposta restituisce un jobArn. Attendi del tempo per completare il lavoro. È possibile verificarne lo stato con il seguente comando.

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

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

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

Acquista un Provisioned Throughput 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 unprovisionedModelArn. Attendi un certo periodo di tempo per la creazione del Provisioned Throughput. Per verificarne lo stato, fornite il nome o ARN il modello fornito come indicato provisioned-model-id nel comando seguente.

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. È necessario fornire ARN il modello fornito come. 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 is AWS?", "textGenerationConfig": {"temperature": 0.5}}' \
    --cli-binary-format raw-in-base64-out \
    output.txt

Esegui il seguente frammento di codice per inviare un lavoro di ottimizzazione. Replace (Sostituisci) ${your-customization-role-arn} con il ARN 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": ".0005",
        "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 del tempo per completare il lavoro. È possibile verificarne lo stato con il seguente comando.

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

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

Acquista un Provisioned Throughput 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 certo periodo di tempo per la creazione del Provisioned Throughput. Per verificarne lo stato, fornite il nome o ARN il modello fornito come indicato provisionedModelId nel comando seguente.

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

Quando lo status èInService, puoi eseguire l'inferenza con il tuo modello personalizzato con il seguente comando. È necessario fornire ARN il modello fornito come. 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 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()