Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Codebeispiele für die Modellanpassung Die folgenden Codebeispiele zeigen, wie Sie einen Basisdatensatz vorbereiten, Berechtigungen einrichten, ein benutzerdefiniertes Modell erstellen, die Ausgabedateien anzeigen, Durchsatz für das Modell erwerben und Inferenzen für das Modell ausführen. Sie können diese Codeausschnitte an Ihren speziellen Anwendungsfall anpassen. 1. Bereiten Sie den Trainingsdatensatz vor. 1. Erstellen Sie eine Trainingsdatensatzdatei, die die folgende Zeile enthält, und benennen Sie sie*train.jsonl*. ``` {"prompt": "what is AWS", "completion": "it's Amazon Web Services"} ``` 1. Erstellen Sie einen S3-Bucket für Ihre Trainingsdaten und einen weiteren für Ihre Ausgabedaten (die Namen müssen eindeutig sein). 1. Laden Sie es *train.jsonl* in den Trainingsdaten-Bucket hoch. 1. Erstellen Sie eine Richtlinie für den Zugriff auf Ihre Trainingsdaten und fügen Sie sie einer IAM-Rolle mit einer Amazon-Bedrock-Vertrauensstellung hinzu. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und führen Sie dann die folgenden Schritte aus: ------ #### [ Console ] 1. Erstellen Sie die S3-Richtlinie. 1. Navigieren Sie unter [https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam) zur IAM-Konsole und wählen Sie im linken **Navigationsbereich Richtlinien** aus. 1. Wählen Sie **Richtlinie erstellen** und anschließend **JSON** aus, um den **Richtlinien-Editor** zu öffnen. 1. **Fügen Sie die folgende Richtlinie ein, ersetzen Sie *\$1\$1training-bucket\$1* und *\$1\$1output-bucket\$1* durch Ihre Bucket-Namen, und wählen Sie dann Weiter aus.** ------ #### [ 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:::${output-bucket}", "arn:aws:s3:::${output-bucket}/*" ] } ] } ``` ------ 1. Geben Sie der Richtlinie einen Namen *MyFineTuningDataAccess* und wählen Sie **Richtlinie erstellen** aus. 1. Erstellen Sie eine IAM-Rolle und fügen Sie die Richtlinie an. 1. Wählen Sie im linken Navigationsbereich die Option **Rollen** und dann **Rolle erstellen** aus. 1. Wählen Sie die Option **Benutzerdefinierte Vertrauensrichtlinie** aus, fügen Sie die folgende Richtlinie ein und wählen Sie dann **Weiter** aus. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Suchen Sie nach der *MyFineTuningDataAccess* Richtlinie, die Sie erstellt haben, aktivieren Sie das Kontrollkästchen und wählen Sie **Weiter**. 1. Benennen Sie die Rolle *MyCustomizationRole* und wählen Sie*Create role*. ------ #### [ CLI ] 1. Erstellen Sie eine Datei mit dem Namen *BedrockTrust.json* und fügen Sie die folgende Richtlinie ein. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Erstellen Sie eine weitere Datei mit dem Namen *MyFineTuningDataAccess.json* und fügen Sie die folgende Richtlinie ein, *\$1\$1output-bucket\$1* wobei Sie Ihre Bucket-Namen durch *\$1\$1training-bucket\$1* und ersetzen. ------ #### [ 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:::${output-bucket}", "arn:aws:s3:::${output-bucket}/*" ] } ] } ``` ------ 1. Navigieren Sie in einem Terminalfenster zu dem Ordner, der die von Ihnen erstellten Richtlinien enthält. 1. Stellen Sie eine [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)Anfrage zur Erstellung einer IAM-Rolle mit dem Namen *MyCustomizationRole* und fügen Sie die von Ihnen erstellte *BedrockTrust.json* Vertrauensrichtlinie hinzu. ``` aws iam create-role \ --role-name MyCustomizationRole \ --assume-role-policy-document file://BedrockTrust.json ``` 1. Stellen Sie eine [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)Anfrage zur Erstellung der S3-Datenzugriffsrichtlinie mit der von Ihnen erstellten *MyFineTuningDataAccess.json* Datei. Die Antwort gibt den Parameter `Arn` für die Richtlinie zurück. ``` aws iam create-policy \ --policy-name MyFineTuningDataAccess \ --policy-document file://myFineTuningDataAccess.json ``` 1. Stellen Sie eine [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)Anfrage, um die S3-Datenzugriffsrichtlinie an Ihre Rolle anzuhängen, und ersetzen Sie die in der Antwort aus dem vorherigen Schritt durch den ARN: `policy-arn` ``` aws iam attach-role-policy \ --role-name MyCustomizationRole \ --policy-arn ${policy-arn} ``` ------ #### [ Python ] 1. Führen Sie den folgenden Code aus, um eine [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)Anfrage zur Erstellung einer IAM-Rolle namens zu stellen *MyCustomizationRole* und um eine [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)Anfrage zur Erstellung einer S3-Datenzugriffsrichtlinie namens *MyFineTuningDataAccess* zu stellen. Ersetzen Sie für die S3-Datenzugriffsrichtlinie *\$1\$1training-bucket\$1* und *\$1\$1output-bucket\$1* durch Ihre S3-Bucket-Namen. ``` 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}/*" ] } ] }) ) ``` 1. In der Antwort wird der Parameter `Arn` zurückgegeben. Führen Sie den folgenden Codeausschnitt aus, um eine [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)Anfrage zu stellen, und *\$1\$1policy-arn\$1* ersetzen Sie ihn durch den zurückgegebenen. `Arn` ``` iam.attach_role_policy( RoleName="MyCustomizationRole", PolicyArn="${policy-arn}" ) ``` ------ 1. Wählen Sie eine Sprache aus, in der Codebeispiele zum Aufrufen der API-Operationen für die Modellanpassung angezeigt werden sollen. ------ #### [ CLI ] Erstellen Sie zunächst eine Textdatei mit dem Namen. *FineTuningData.json* Kopieren Sie den JSON-Code von unten in die Textdatei *\$1\$1training-bucket\$1* und *\$1\$1output-bucket\$1* ersetzen Sie ihn durch Ihre S3-Bucket-Namen. ``` { "trainingDataConfig": { "s3Uri": "s3://${training-bucket}/train.jsonl" }, "outputDataConfig": { "s3Uri": "s3://${output-bucket}" } } ``` Um einen Auftrag zur Modellanpassung einzureichen, navigieren Sie zu dem Ordner, der sich *FineTuningData.json* in einem Terminal befindet, und führen Sie den folgenden Befehl in der Befehlszeile aus. *\$1\$1your-customization-role-arn\$1* Ersetzen Sie ihn durch die Rolle für die Modellanpassung, die Sie eingerichtet haben. ``` 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 ``` In der Antwort wird ein *jobArn* zurückgegeben. Warten Sie, bis der Auftrag abgeschlossen ist. Sie können den Status mit dem folgenden Befehl überprüfen. ``` aws bedrock get-model-customization-job \ --job-identifier "jobArn" ``` Wenn der `status` `COMPLETE` lautet, können Sie die `trainingMetrics` in der Antwort sehen. Sie können die Artefakte in den aktuellen Ordner herunterladen, indem Sie den folgenden Befehl ausführen und ihn *aet.et-bucket* durch den Namen Ihres Ausgabe-Buckets und *jobId* die ID des Anpassungsauftrags ersetzen (die Reihenfolge nach dem letzten Schrägstrich in`jobArn`). ``` aws s3 cp s3://${output-bucket}/model-customization-job-jobId . --recursive ``` Erwerben Sie mit dem folgenden Befehl einen unverbindlichen bereitgestellten Durchsatz für Ihr benutzerdefiniertes Modell. **Anmerkung** Dieser Kauf wird Ihnen auf Stundenbasis in Rechnung gestellt. Verwenden Sie die Konsole, um Preisschätzungen für verschiedene Optionen einzusehen. ``` aws bedrock create-provisioned-model-throughput \ --model-id MyCustomModel \ --provisioned-model-name MyProvisionedCustomModel \ --model-units 1 ``` In der Antwort wird ein `provisionedModelArn` zurückgegeben. Warten Sie, bis der bereitgestellte Durchsatz erstellt wurde. Zum Überprüfen des Status geben Sie den Namen oder den ARN des bereitgestellten Modells als `provisioned-model-id` im folgenden Befehl ein. ``` aws bedrock get-provisioned-model-throughput \ --provisioned-model-id ${provisioned-model-arn} ``` Wenn der `status` `InService` lautet, können Sie mit dem folgenden Befehl Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen den ARN des bereitgestellten Modells als `model-id` angeben. Die Ausgabe wird in eine Datei mit dem Namen *output.txt* in Ihrem aktuellen Ordner geschrieben. ``` 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 ] Führen Sie den folgenden Codeausschnitt aus, um einen Feinabstimmungsauftrag zu übermitteln. *\$1\$1your-customization-role-arn\$1*Ersetzen Sie es durch den ARN des*MyCustomizationRole*, den Sie eingerichtet und ersetzt haben, *\$1\$1training-bucket\$1* und *\$1\$1output-bucket\$1* durch Ihre S3-Bucket-Namen. ``` 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') ``` In der Antwort wird ein *jobArn* zurückgegeben. Warten Sie, bis der Auftrag abgeschlossen ist. Sie können den Status mit dem folgenden Befehl überprüfen. ``` bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status') ``` Wenn ja `status``COMPLETE`, können Sie das `trainingMetrics` in der [GetModelCustomizationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetModelCustomizationJob.html)Antwort sehen. Sie können auch den Schritten unter [Herunterladen von Objekten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html) folgen, um die Metriken herunterzuladen. Erwerben Sie mit dem folgenden Befehl einen unverbindlichen bereitgestellten Durchsatz für Ihr benutzerdefiniertes Modell. ``` response_pt = bedrock.create_provisioned_model_throughput( modelId="MyCustomModel", provisionedModelName="MyProvisionedCustomModel", modelUnits="1" ) provisionedModelArn = response_pt.get('provisionedModelArn') ``` In der Antwort wird ein `provisionedModelArn` zurückgegeben. Warten Sie, bis der bereitgestellte Durchsatz erstellt wurde. Zum Überprüfen des Status geben Sie den Namen oder den ARN des bereitgestellten Modells als `provisionedModelId` im folgenden Befehl ein. ``` bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn) ``` Wenn der `status` `InService` lautet, können Sie mit dem folgenden Befehl Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen den ARN des bereitgestellten Modells als `modelId` angeben. ``` 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() ``` ------