모델 커스터마이징을 위한 코드 샘플

먼저, 라는 텍스트 파일을 생성합니다.FineTuningData.json. 아래 JSON 코드를 텍스트 파일에 복사하여 바꾸십시오.${training-bucket} 그리고 ${output-bucket} S3 버킷 이름을 사용하세요.

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

모델 사용자 지정 작업을 제출하려면 포함된 폴더로 이동하십시오.FineTuningData.json 터미널에서 명령줄에서 다음 명령을 실행하여 다음을 대체합니다.${your-customization-role-arn} 설정한 모델 사용자 지정 역할을 사용합니다.

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
                

응답은 a를 반환합니다.jobArn. 작업이 완료될 때까지 잠시 기다려 주세요. 다음 명령으로 상태를 확인할 수 있습니다.

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

statusCOMPLETE인 경우 trainingMetrics 응답에서 를 확인할 수 있습니다. 다음 명령을 실행하고 다음을 대체하여 현재 폴더로 아티팩트를 다운로드할 수 있습니다.aet.et-bucket 출력 버킷 이름과 함께 jobId 사용자 지정 작업의 ID (의 마지막 슬래시 뒤에 오는 순서jobArn) 와 함께

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

다음 명령어를 사용하여 사용자 지정 모델에 사용할 프로비저닝 처리량을 약정 없이 구매하세요.

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

응답은 a를 반환합니다provisionedModelArn. 프로비저닝된 처리량이 생성될 때까지 잠시 기다려 주십시오. 상태를 확인하려면 다음 명령과 같이 프로비저닝된 ARN 모델의 이름 또는 이름을 입력합니다. provisioned-model-id

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

statusInService인 경우 다음 명령을 사용하여 사용자 지정 모델을 사용하여 추론을 실행할 수 있습니다. ARN프로비저닝된 모델을 로 제공해야 합니다. model-id 출력은 이라는 파일에 기록됩니다.output.txt 현재 폴더에서

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

다음 코드 스니펫을 실행하여 미세 조정 작업을 제출하십시오. Replace ${your-customization-role-arn} 다음과 같이 ARN MyCustomizationRole 설치하고 교체한 ${training-bucket} 그리고 ${output-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')

응답은 a를 반환합니다.jobArn. 작업이 완료될 때까지 잠시 기다려 주세요. 다음 명령으로 상태를 확인할 수 있습니다.

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

statusCOMPLETE인 경우 trainingMetrics GetModelCustomizationJob응답에서 를 확인할 수 있습니다. 객체 다운로드의 단계에 따라 지표를 다운로드할 수도 있습니다.

다음 명령어를 사용하여 사용자 지정 모델용 프로비저닝 처리량을 약정 없이 구매하세요.

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

provisionedModelArn = response_pt.get('provisionedModelArn')

응답은 a를 반환합니다. provisionedModelArn 프로비저닝된 처리량이 생성될 때까지 잠시 기다려 주십시오. 상태를 확인하려면 다음 명령과 같이 프로비저닝된 ARN 모델의 이름 또는 이름을 입력합니다. provisionedModelId

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

statusInService인 경우 다음 명령을 사용하여 사용자 지정 모델을 사용하여 추론을 실행할 수 있습니다. ARN프로비저닝된 모델을 로 제공해야 합니다. 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()