模型自訂的程式碼範例

下列程式碼範例示範如何準備基本資料集、設定許可、建立自訂模型、檢視輸出檔案、購買模型的輸送量，以及在模型上執行推論。您可以將這些程式碼片段修改為特定使用案例。

準備訓練資料集。
1. 建立訓練資料集檔案，其中包含以下一行並命名 train.jsonl.
```
{"prompt": "what is AWS", "completion": "it's Amazon Web Services"}
```
2. 為您的訓練資料建立 S3 儲存貯體，並為輸出資料建立另一個儲存貯體（名稱必須是唯一的）。
3. 上傳 train.jsonl 訓練資料儲存貯體中。

建立政策以存取您的訓練，並將其連接至具有 Amazon Bedrock 信任關係IAM的角色。選取與您所選方法對應的索引標籤，然後遵循下列步驟：

Console

建立 S3 政策。

在 https://console.aws.amazon.com/iam 導覽至IAM主控台，然後從左側導覽窗格中選擇政策。
選取建立政策，然後選擇JSON開啟政策編輯器。

貼上下列政策，取代 ${training-bucket} 以及 ${output-bucket} ，然後選擇下一個 。


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${training-bucket}",
                "arn:aws:s3:::${training-bucket}/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${output-bucket}",
                "arn:aws:s3:::${output-bucket}/*"
            ]
        }
    ]
}

為政策命名 MyFineTuningDataAccess 然後選取建立政策 。

建立IAM角色並附加政策。
1. 從左側導覽窗格中，選擇角色，然後選擇建立角色 。
2. 選取自訂信任政策 ，貼上下列政策，然後選取下一個 。
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}
```
3. 搜尋 MyFineTuningDataAccess 政策，選取核取方塊，然後選擇下一步。
4. 為角色命名 MyCustomizationRole 然後選取 Create role.

CLI

建立名為的檔案 BedrockTrust.json 並將下列政策貼到其中。


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}

建立另一個名為的檔案 MyFineTuningDataAccess.json 並將下列政策貼到其中，取代 ${training-bucket} 以及 ${output-bucket} 儲存貯體名稱。


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${training-bucket}",
                "arn:aws:s3:::${training-bucket}/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${output-bucket}",
                "arn:aws:s3:::${output-bucket}/*"
            ]
        }
    ]
}

在終端機中，導覽至包含您建立之政策的資料夾。
提出建立名為 IAM之角色的CreateRole請求 MyCustomizationRole 並連接 BedrockTrust.json 您建立的信任政策。
```
aws iam create-role \
    --role-name MyCustomizationRole \
    --assume-role-policy-document file://BedrockTrust.json
```
使用 CreatePolicy請求建立 S3 資料存取政策 MyFineTuningDataAccess.json 您建立的檔案。回應會傳回政策Arn的。
```
aws iam create-policy \
    --policy-name MyFineTuningDataAccess \
    --policy-document file://myFineTuningDataAccess.json
```
AttachRolePolicy 請求將 S3 資料存取政策連接至您的角色，在上一個步驟的回應ARN中將取代policy-arn為：
```
aws iam attach-role-policy \
    --role-name MyCustomizationRole \
    --policy-arn ${policy-arn}
```

Python

執行下列程式碼，CreateRole請求建立名為 IAM的角色 MyCustomizationRole 並CreatePolicy請求建立名為的 S3 資料存取政策 MyFineTuningDataAccess。對於 S3 資料存取政策，請取代 ${training-bucket} 以及 ${output-bucket} 您的 S3 儲存貯體名稱。


import boto3
import json

iam = boto3.client("iam")

iam.create_role(
    RoleName="MyCustomizationRole",
    AssumeRolePolicyDocument=json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": "bedrock.amazonaws.com"
                },
                "Action": "sts:AssumeRole"
            }
        ] 
    })
)

iam.create_policy(
    PolicyName="MyFineTuningDataAccess",
    PolicyDocument=json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:GetObject",
                    "s3:ListBucket"
                ],
                "Resource": [
                    "arn:aws:s3:::${training-bucket}",
                    "arn:aws:s3:::${training-bucket}/*"
                ]
            },
            {
                "Effect": "Allow",
                "Action": [
                    "s3:GetObject",
                    "s3:PutObject",
                    "s3:ListBucket"
                ],
                "Resource": [
                    "arn:aws:s3:::${output-bucket}",
                    "arn:aws:s3:::${output-bucket}/*"
                ]
            }
        ]
    })
)

回應中Arn會傳回。執行下列程式碼片段以提出AttachRolePolicy請求、取代 ${policy-arn} 傳回的 Arn。
```
iam.attach_role_policy(
    RoleName="MyCustomizationRole",
    PolicyArn="${policy-arn}"
)
```

選取語言以查看程式碼範例，以呼叫模型自訂API操作。

CLI

首先，建立名為的文字檔案 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

回應傳回 jobArn。讓任務有時間完成。您可以使用下列命令來檢查其狀態。


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

當 status為時COMPLETE，您可以在回應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

回應會傳回 provisionedModelArn。預留一些時間來建立佈建輸送量。若要檢查其狀態，請在下列命令provisioned-model-id中提供佈建模型的名稱或 ARN 作為。


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

當 status為時InService，您可以使用下列命令，使用自訂模型執行推論。您必須提供佈建模型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

Python

執行下列程式碼片段以提交微調任務。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')

回應傳回 jobArn。讓任務有時間完成。您可以使用下列命令來檢查其狀態。


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

當 status為時COMPLETE，您可以在GetModelCustomizationJob回應trainingMetrics中看到。您也可以遵循下載物件的步驟來下載指標。

使用下列命令為您的自訂模型購買無承諾佈建輸送量。


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

provisionedModelArn = response_pt.get('provisionedModelArn')

回應會傳回 provisionedModelArn。預留一些時間來建立佈建輸送量。若要檢查其狀態，請在下列命令provisionedModelId中提供佈建模型的名稱或 ARN 作為。


bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

當 status為時InService，您可以使用下列命令，使用自訂模型執行推論。您必須提供佈建模型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()

您的瀏覽器已停用或無法使用 Javascript。

您必須啟用 Javascript，才能使用 AWS 文件。請參閱您的瀏覽器說明頁以取得說明。

文件慣用形式

使用自訂模型

刪除自訂模型