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.
Schulung eines Amazon-Rekognition-Custom-Labels-Modells
Sie können ein Modell mithilfe der Amazon Rekognition Custom Labels-Konsole oder der Amazon Rekognition Custom Labels API trainieren. Schlägt das Modelltraining fehl, verwenden Sie die Informationen inDebuggen eines fehlgeschlagenen Modelltrainings, um die Ursache des Fehlers zu ermitteln.
Ihnen wird die Zeit in Rechnung gestellt, die benötigt wird, um ein Modell erfolgreich zu trainieren. In der Regel dauert das Training 30 Minuten bis 24 Stunden. Weitere Informationen finden Sie unter Trainingszeiten.
Jedes Mal, wenn das Modell trainiert wird, wird eine neue Version eines Modells erstellt. Amazon Rekognition Custom Labels erstellt einen Namen für das Modell, der eine Kombination aus dem Projektnamen und dem Zeitstempel für die Erstellung des Modells ist.
Um Ihr Modell zu trainieren, erstellt Amazon Rekognition Custom Labels eine Kopie Ihrer ursprünglichen Trainings- und Testbilder. Standardmäßig werden die kopierten Bilder im Ruhezustand mit einem Schlüssel verschlüsselt, der AWS besitzt und verwaltet. Sie können auch Ihre eigenen verwendenAWS KMS key. Wenn Sie Ihren eigenen KMS-Schlüssel verwenden, benötigen Sie die folgenden Berechtigungen für den KMS-Schlüssel.
km:CreateGrant
km:DescribeKey
Weitere Informationen finden Sie im unter AWS Key Management Service Service-Konzepte. Ihre Quellbilder sind davon nicht betroffen.
Sie können die serverseitige KMS-Verschlüsselung (SSE-KMS) verwenden, um die Trainings- und Testbilder in Ihrem Amazon S3 S3-Bucket zu verschlüsseln, bevor sie von Amazon Rekognition Custom Labels kopiert werden. Um Amazon Rekognition Custom Labels Zugriff auf Ihre Bilder zu gewähren, benötigt IhrAWS Konto die folgenden Berechtigungen für den KMS-Schlüssel.
km:GenerateDataKey
kms:Decrypt
Weitere Informationen finden Sie im unter Schutz von Daten mit serverseitiger Verschlüsselung mit in AWS Key Management Service (SSE-KMS) gespeicherten KMS-Schlüsseln
Nach dem Training eines Modells können Sie dessen Leistung bewerten und Verbesserungen vornehmen. Weitere Informationen finden Sie unter Verbessern eines geschulten Amazon Rekognition Custom Labels-Modells.
Weitere Modellaufgaben, wie das Taggen eines Modells, finden Sie unterVerwaltung eines Amazon-Rekognition-Custom-Labels-Modells.
Ein Model trainieren (Konsole)
Sie können die Amazon Rekognition Custom Labels-Konsole verwenden, um ein Modell zu trainieren.
Das Training erfordert ein Projekt mit einem Trainingsdatensatz und einem Testdatensatz. Wenn Ihr Projekt keinen Testdatensatz hat, teilt die Amazon Rekognition Custom Labels-Konsole den Trainingsdatensatz während des Trainings auf, um einen für Ihr Projekt zu erstellen. Die ausgewählten Bilder sind eine repräsentative Stichprobe und werden nicht im Trainingsdatensatz verwendet. Wir empfehlen, Ihren Trainingsdatensatz nur zu teilen, wenn Sie keinen alternativen Testdatensatz haben, den Sie verwenden können. Durch das Aufteilen eines Trainingsdatensatzes wird die Anzahl der für das Training verfügbaren Bilder reduziert.
Ihnen wird die Zeit in Rechnung gestellt, die für das Trainieren eines Modells benötigt wird. Weitere Informationen finden Sie unter Trainingszeiten.
Um dein Modell zu trainieren (Konsole)
Öffnen Sie die Amazon Rekognition Rekognition-Konsole unter https://console.aws.amazon.com/rekognition/.
Wählen Sie „Benutzerdefinierte Labels verwenden“.
Wählen Sie im linken Navigationsbereich die Option Projekte aus.
Wählen Sie auf der Seite Projekte das Projekt aus, das das Modell enthält, das Sie trainieren möchten.
Wählen Sie auf der Projektseite Zugmodell aus.
(Optional) Wenn Sie Ihren eigenen AWS KMS KMS-Verschlüsselungsschlüssel verwenden möchten, gehen Sie wie folgt vor:
Wählen Sie unter Bilddatenverschlüsselung die Option Verschlüsselungseinstellungen anpassen (erweitert).
Geben Sie unter encryption.aws_kms_key den Amazon Resource Name (ARN) Ihres Schlüssels ein, oder wählen Sie einen vorhandenen AWS KMS KMS-Schlüssel aus. Um einen neuen Schlüssel zu erstellen, wählen Sie Create an AWS IMS-Schlüssel.
(Optional) gehen Sie wie folgt vor, wenn Sie Ihrem Modell Tags hinzufügen möchten:
Wählen Sie im Abschnitt Tags die Option Neues Tag hinzufügen aus.
Geben Sie Folgendes ein:
Der Name des Schlüssels in Key.
Der Wert des Schlüssels in Value.
Um weitere Tags hinzuzufügen, wiederholen Sie die Schritte 6a und 6b.
(Optional) neben dem Tag, das Sie entfernen möchten. Wenn Sie ein zuvor gespeichertes Tag entfernen, wird es entfernt, wenn Sie Ihre Änderungen speichern.
Wählen Sie auf der Seite Zugmodell die Option Zugmodell aus. Der Amazon-Ressourcenname (ARN) für Ihr Projekt sollte im Bearbeitungsfeld für Amazon Resource Name (ARN) für Ihr Projekt angegeben werden. Wenn nicht, geben Sie den ARN für Ihr Projekt ein.
In der Möchtest du dein Model trainieren? Wählen Sie in einem Dialogfenster die Option Zugmodell aus.
Im Bereich Modelle auf der Projektseite kannst du den aktuellen Status in derModel Status Spalte überprüfen, in der das Training läuft. Es dauert eine Weile, bis das Training eines Modells abgeschlossen ist.
Wählen Sie nach Abschluss des Trainings den Modellnamen. Das Training ist beendet, wenn der Modellstatus TRAINING_COMPLETED ist. Wenn das Training fehlschlägt, lesen SieDebuggen eines fehlgeschlagenen Modelltrainings.
Nächster Schritt: Evaluieren Sie Ihr Modell. Weitere Informationen finden Sie unter Verbessern eines geschulten Amazon Rekognition Custom Labels-Modells.
Ein Modell trainieren (SDK)
Du trainierst ein Model, indem du anrufst CreateProjectVersion. Um ein Modell zu trainieren, werden die folgenden Informationen benötigt:
Name — Ein eindeutiger Name für die Modellversion.
Project ARN) des Projekts, das das Modell verwaltet.
Ort der Schulungsergebnisse — Der Amazon S3 S3-Standort, an dem die Ergebnisse platziert werden. Sie können denselben Speicherort wie den Amazon S3 S3-Bucket für die Konsole verwenden, oder Sie können einen anderen Standort wählen. Wir empfehlen, einen anderen Standort zu wählen, da Sie auf diese Weise Berechtigungen festlegen und mögliche Namenskonflikte mit dem Trainingsergebnis vermeiden können, das sich aus der Verwendung der Amazon Rekognition Custom Labels-Konsole ergibt.
Das Training verwendet die mit dem Projekt verknüpften Trainings- und Testdatensätze. Weitere Informationen finden Sie unter Verwalten von Datensätzen.
Optional können Sie Manifestdateien für Trainings- und Testdatensätze angeben, die sich außerhalb eines Projekts befinden. Wenn Sie die Konsole öffnen, nachdem Sie ein Modell mit externen Manifestdateien trainiert haben, erstellt Amazon Rekognition Custom Labels die Datensätze für Sie, indem es den letzten Satz von Manifestdateien verwendet, die für das Training verwendet wurden. Sie können eine Modellversion für das Projekt nicht mehr trainieren, indem Sie externe Manifestdateien angeben. Weitere Informationen finden Sie unter CreatePrjectVersion.
Die Antwort vonCreateProjectVersion ist ein ARN, mit dem Sie die Modellversion in nachfolgenden Anfragen identifizieren. Sie können auch die ARN verwenden, um die Modellversion zu sichern. Weitere Informationen finden Sie unter Sicherung von Amazon Rekognition Custom Labels-Projekten.
Es dauert eine Weile, bis das Training einer Modellversion abgeschlossen ist. In den Python- und Java-Beispielen in diesem Thema warten Kellner auf den Abschluss der Schulung. Ein Kellner ist eine nützliche Methode, mit der nach einem bestimmten Bundesstaat gefragt wird. Alternativ können Sie sich telefonisch über den aktuellen Stand der Schulung informierenDescribeProjectVersions. Das Training ist abgeschlossen, wenn derStatus Feldwert beträgtTRAINING_COMPLETED. Nach Abschluss des Trainings können Sie die Qualität des Modells bewerten, indem Sie die Bewertungsergebnisse überprüfen.
Ein Modell trainieren (SDK)
Das folgende Beispiel zeigt, wie ein Modell mithilfe der einem Projekt zugeordneten Trainings- und Testdatensätze trainiert wird.
Um ein Modell zu trainieren (SDK)
-
Falls noch nicht erfolgt, installieren und konfigurieren Sie dieAWS CLIAWS SDKs. Weitere Informationen finden Sie unter Schritt 4: Richten Sie die AWS CLI und SDKs ein AWS.
Verwenden Sie den folgenden Beispielcode, um ein Projekt zu trainieren.
- AWS CLI
-
Im folgenden Beispiel wird ein Modell erstellt. Der Trainingsdatensatz wird aufgeteilt, um den Testdatensatz zu erstellen. Ersetzen Sie Folgendes:
-
my_project_arnmit dem Amazon-Ressourcennamen (ARN) des Projekts.
-
version_namemit einem eindeutigen Versionsnamen Ihrer Wahl.
-
output_bucketmit dem Namen des Amazon-S3-Buckets, in dem Amazon Rekognition Custom Labels die Trainingsergebnisse speichert.
-
output_foldermit dem Namen des Ordners, in dem die Trainingsergebnisse gespeichert werden.
(optionaler Parameter)--kms-key-id mit einer Kennung für Ihren AWS Key Management Service Service-Kundenmasterschlüssel.
aws rekognition create-project-version \
--project-arn project_arn \
--version-name version_name \
--output-config '{"S3Bucket":"output_bucket", "S3KeyPrefix":"output_folder"}' \
--profile custom-labels-access
- Python
-
Im folgenden Beispiel wird ein Modell erstellt. Geben Sie die folgenden Befehlszeilenargumente an:
project_arn— Der Amazon-Ressourcenname (ARN) des Projekts.
version_name— Ein eindeutiger Versionsname für das Modell Ihrer Wahl.
output_bucket— Der Name des Amazon-S3-Buckets, in dem Amazon Rekognition Custom Labels die Trainingsergebnisse speichert.
output_folder— der Name des Ordners, in dem die Trainingsergebnisse gespeichert werden.
Geben Sie optional die folgenden Befehlszeilenparameter an, um Ihrem Modell ein Tag zuzuordnen:
#Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import argparse
import logging
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def train_model(rek_client, project_arn, version_name, output_bucket, output_folder, tag_key, tag_key_value):
"""
Trains an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to train a model.
:param version_name: A version for the model.
:param output_bucket: The S3 bucket that hosts training output.
:param output_folder: The path for the training output within output_bucket
:param tag_key: The name of a tag to attach to the model. Pass None to exclude
:param tag_key_value: The value of the tag. Pass None to exclude
"""
try:
#Train the model
status=""
logger.info("training model version %s for project %s",
version_name, project_arn)
output_config = json.loads(
'{"S3Bucket": "'
+ output_bucket
+ '", "S3KeyPrefix": "'
+ output_folder
+ '" } '
)
tags={}
if tag_key is not None and tag_key_value is not None:
tags = json.loads(
'{"' + tag_key + '":"' + tag_key_value + '"}'
)
response=rek_client.create_project_version(
ProjectArn=project_arn,
VersionName=version_name,
OutputConfig=output_config,
Tags=tags
)
logger.info("Started training: %s", response['ProjectVersionArn'])
# Wait for the project version training to complete.
project_version_training_completed_waiter = rek_client.get_waiter('project_version_training_completed')
project_version_training_completed_waiter.wait(ProjectArn=project_arn,
VersionNames=[version_name])
# Get the completion status.
describe_response=rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in describe_response['ProjectVersionDescriptions']:
logger.info("Status: %s", model['Status'])
logger.info("Message: %s", model['StatusMessage'])
status=model['Status']
logger.info("finished training")
return response['ProjectVersionArn'], status
except ClientError as err:
logger.exception("Couldn't create model: %s", err.response['Error']['Message'] )
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project in which you want to train a model"
)
parser.add_argument(
"version_name", help="A version name of your choosing."
)
parser.add_argument(
"output_bucket", help="The S3 bucket that receives the training results."
)
parser.add_argument(
"output_folder", help="The folder in the S3 bucket where training results are stored."
)
parser.add_argument(
"--tag_name", help="The name of a tag to attach to the model", required=False
)
parser.add_argument(
"--tag_value", help="The value for the tag.", required=False
)
def main():
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
try:
# Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(f"Training model version {args.version_name} for project {args.project_arn}")
# Train the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
model_arn, status=train_model(rekognition_client,
args.project_arn,
args.version_name,
args.output_bucket,
args.output_folder,
args.tag_name,
args.tag_value)
print(f"Finished training model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
except Exception as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
if __name__ == "__main__":
main()
- Java V2
-
Im folgenden Beispiel wird ein Modell trainiert. Geben Sie die folgenden Befehlszeilenargumente an:
project_arn— Der Amazon-Ressourcenname (ARN) des Projekts.
version_name— Ein eindeutiger Versionsname für das Modell Ihrer Wahl.
output_bucket— Der Name des Amazon-S3-Buckets, in dem Amazon Rekognition Custom Labels die Trainingsergebnisse speichert.
output_folder— der Name des Ordners, in dem die Trainingsergebnisse gespeichert werden.
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TrainModel {
public static final Logger logger = Logger.getLogger(TrainModel.class.getName());
public static String trainMyModel(RekognitionClient rekClient, String projectArn, String versionName,
String outputBucket, String outputFolder) {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
logger.log(Level.INFO, "Training Model for project {0}", projectArn);
CreateProjectVersionRequest createProjectVersionRequest = CreateProjectVersionRequest.builder()
.projectArn(projectArn).versionName(versionName).outputConfig(outputConfig).build();
CreateProjectVersionResponse response = rekClient.createProjectVersion(createProjectVersionRequest);
logger.log(Level.INFO, "Model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Training model...");
// wait until training completes
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(projectArn)
.build();
RekognitionWaiter waiter = rekClient.waiter();
WaiterResponse<DescribeProjectVersionsResponse> waiterResponse = waiter
.waitUntilProjectVersionTrainingCompleted(describeProjectVersionsRequest);
Optional<DescribeProjectVersionsResponse> optionalResponse = waiterResponse.matched().response();
DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
System.out.println("Status: " + projectVersionDescription.statusAsString());
System.out.println("Message: " + projectVersionDescription.statusMessage());
}
return response.projectVersionArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String versionName = null;
String projectArn = null;
String projectVersionArn = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: " + "<project_name> <version_name> <output_bucket> <output_folder>\n\n" + "Where:\n"
+ " project_arn - The ARN of the project that you want to use. \n\n"
+ " version_name - A version name for the model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
versionName = args[1];
bucket = args[2];
location = args[3];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Train model
projectVersionArn = trainMyModel(rekClient, projectArn, versionName, bucket, location);
System.out.println(String.format("Created model: %s for Project ARN: %s", projectVersionArn, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
Wenn das Training fehlschlägt, lesen SieDebuggen eines fehlgeschlagenen Modelltrainings.
