模型自訂的程式碼範例

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

1. 準備訓練資料集。

   1. 建立包含下列一行的訓練資料集檔案，並將其命名為 tra. jsonl。

      {"prompt": "what is AWS", "completion": "it's Amazon Web Services"}

   2. 為訓練資料建立 S3 儲存貯體，為輸出資料建立另一個儲存貯體 (名稱必須是唯一的)。

   3. 將火車 .jsonl 上傳至訓練資料儲存貯體。

2. 建立政策以存取您的訓練，並將其附加到具有 Amazon 基岩信任關係的 IAM 角色。選擇與您選擇的方法相對應的選項卡，然後按照步驟操作。

   Console

   1. 建立 S3 政策。

      1. 瀏覽至 IAM 主控台 https://console.aws.amazon.com/iam，然後從左側導覽窗格中選擇「政策」。

      2. 選取 [建立原則]，然後選擇 [JSON] 以開啟 [原則編輯器]。

      3. 貼上下列原則，將 $ {訓練值區} 和 $ {輸出值區} 取代為您的值區名稱，然後選取 [下一步]。

         {
             "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}/*"
                     ]
                 }
             ]
         }

      4. 為原則命名，MyFineTuningDataAccess然後選取建立原則。

   2. 建立 IAM 角色並附加政策。

      1. 在左側導覽窗格中，選擇 [角色]，然後選取 [建立角色]。

      2. 選取 [自訂信任原則]，貼上下列原則，然後選取 [下一步]。

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

      3. 搜尋您建立的MyFineTuningDataAccess策略，選取核取方塊，然後選擇 [下一步]。

      4. 為角色命名，MyCustomizationRole然後選取建立角色。

   CLI

   1. 建立名為 BedrockTrust.json 的檔案，並將下列原則貼入其中。

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

   2. 創建另一個名為 MyFineTuningDataAccess.json 的文件，並將以下策略粘貼到其中，將 $ {訓練桶} 和 $ {輸出桶} 替換為您的存儲桶名稱。

      {
          "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:::${training-bucket}",
                      "arn:aws:s3:::${training-bucket}/*"
                  ]
              }
          ]
      }

   3. 在終端機中，導覽至包含您建立之規則的資料夾。

   4. 提出要CreateRole求以建立名為的 IAM 角色，MyCustomizationRole並附加您建立的 BedrockTrust.json 信任政策。

      aws iam create-role \
          --role-name MyCustomizationRole \
          --assume-role-policy-document file://BedrockTrust.json

   5. CreatePolicy請求使用您建立的 MyFineTuningDataAccess.json 檔案建立 S3 資料存取政策。回應會傳回Arn原則的。

      aws iam create-policy \
          --policy-name MyFineTuningDataAccess \
          --policy-document file://myFineTuningDataAccess.json

   6. AttachRolePolicy提出要求將 S3 資料存取政策附加至您的角色，並在policy-arn上一步回應中以 ARN 取代：

      aws iam attach-role-policy \
          --role-name MyCustomizationRole \
          --policy-arn ${policy-arn}

   Python

   1. 執行下列程式碼以CreateRole提出建立名為的 IAM 角色的請求，MyCustomizationRole並提出要CreatePolicy求以建立名為的 S3 資料存取政策MyFineTuningDataAccess。對於 S3 資料存取政策，請將 $ {訓練儲存貯體} 和 $ {輸出儲存貯體} 取代為 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}/*"
                      ]
                  }
              ]
          })
      )

   2. Arn在回應中傳回。執行下列程式碼片段以提出AttachRolePolicy要求，將 $ {policy-arn} 取代為傳回的項目。Arn

      iam.attach_role_policy(
          RoleName="MyCustomizationRole",
          PolicyArn="${policy-arn}"
      )

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

CLI

首先，創建一個名為 FineTuningData.json 的文本文件。將 JSON 代碼從下面複製到文本文件中，將 $ {訓練桶} 和 $ {輸出桶} 替換為您的 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 下載成品到目前的資料夾，將 aet.et-bucket 取代為您的輸出值區名稱，並使用自訂工作的 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

執行下列程式碼片段以提交微調工作。將 $ {your-customization-role-arn} 替換為您設置的 ARN MyCustomizationRole，並將 $ {訓練桶} 和 $ {輸出桶} 替換為 S3 存儲桶名稱。

import boto3
import json

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