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.
# Verwalten von Datensätzen
Ein Datensatz enthält die Bilder und zugewiesenen Labels, die Sie zum Trainieren oder Testen eines Modells verwenden. Die Themen in diesem Abschnitt zeigen Ihnen, wie Sie einen Datensatz mit der Amazon Rekognition Custom Labels-Konsole und dem AWS SDK verwalten.
**Topics**
+ [Einen Datensatz zu einem Projekt hinzufügen](md-add-dataset.md)
+ [Weitere Bilder zu einem Datensatz hinzufügen](md-add-images.md)
+ [Erstellen eines Datensatzes mit einem vorhandenen Datensatz (SDK)](md-create-dataset-existing-dataset-sdk.md)
+ [Beschreibung eines Datensatzes (SDK)](md-describing-dataset-sdk.md)
+ [Auflisten von Datensatzeinträgen (SDK)](md-listing-dataset-entries-sdk.md)
+ [Verteilen eines Trainingsdatensatzes (SDK)](md-distributing-datasets.md)
+ [Löschen eines Datensatzes](md-delete-dataset.md)
# Einen Datensatz zu einem Projekt hinzufügen
Sie können einem vorhandenen Projekt einen Trainingsdatensatz oder einen Testdatensatz hinzufügen. Wenn Sie einen vorhandenen Datensatz ersetzen möchten, löschen Sie zuerst den vorhandenen Datensatz. Weitere Informationen finden Sie unter [Löschen eines Datensatzes](md-delete-dataset.md). Fügen Sie dann den neuen Datensatz hinzu.
**Topics**
+ [Hinzufügen eines Datensatzes zu einem Projekt (Konsole)](#md-add-dataset-console)
+ [Hinzufügen eines Datensatzes zu einem Projekt (SDK)](#md-add-dataset-sdk)
## Hinzufügen eines Datensatzes zu einem Projekt (Konsole)
Mithilfe der Amazon Rekognition Custom Labels-Konsole können Sie einem Projekt einen Trainings- oder Testdatensatz hinzufügen.
**So fügen Sie einen Datensatz zu einem Projekt hinzu**
1. Öffnen Sie die Amazon Rekognition Rekognition-Konsole unter. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Wählen Sie im linken Navigationsbereich **Custom Labels verwenden** aus. Die Landingpage von Amazon Rekognition Custom Labels wird angezeigt.
1. Wählen Sie im linken Navigationsbereich die Option **Projekte** aus. Die Projektansicht wird angezeigt.
1. Wählen Sie das Projekt aus, zu dem Sie einen Datensatz hinzufügen möchten.
1. Wählen Sie im linken Navigationsbereich unter dem Projektnamen **Datensätze** aus.
1. Wenn für das Projekt kein Datensatz vorhanden ist, wird die Seite **Datensatz erstellen** angezeigt. Gehen Sie wie folgt vor:
1. Geben Sie auf der Seite **Datensatz erstellen** die Informationen zur Bildquelle ein. Weitere Informationen finden Sie unter [Erstellen von Trainings- und Testdatensätzen mit Bildern](md-create-dataset.md).
1. Wählen Sie **Datensatz erstellen**, um den Datensatz zu erstellen.
1. Wenn für das Projekt bereits ein Datensatz vorhanden ist (Training oder Test), wird die Seite mit den Projektdetails angezeigt. Gehen Sie wie folgt vor:
1. Wählen Sie auf der Seite mit den Projektdetails die Option **Aktionen** aus.
1. Wenn Sie einen Trainingsdatensatz hinzufügen möchten, wählen Sie **Trainingsdatensatz erstellen** aus.
1. Wenn Sie einen Testdatensatz hinzufügen möchten, wählen Sie **Testdatensatz erstellen**.
1. Geben Sie auf der Seite **Datensatz erstellen** die Informationen zur Bildquelle ein. Weitere Informationen finden Sie unter [Erstellen von Trainings- und Testdatensätzen mit Bildern](md-create-dataset.md).
1. Wählen Sie **Datensatz erstellen**, um den Datensatz zu erstellen.
1. Fügen Sie Ihrem Datensatz Bilder hinzu. Weitere Informationen finden Sie unter [Weitere Bilder hinzufügen (Konsole)](md-add-images.md#md-add-images-console).
1. Fügen Sie Ihrem Datensatz Labels hinzu. Weitere Informationen finden Sie unter [Neue Labels hinzufügen (Konsole)](md-labels.md#md-add-new-labels).
1. Fügen Sie Ihren Bildern Labels hinzu. Informationen zum Hinzufügen von Labels auf Bildebene finden Sie unter [Einem Bild Labels auf Bildebene zuweisen](md-assign-image-level-labels.md). Informationen zum Hinzufügen von Begrenzungsrahmen finden Sie unter [Objekte mit Begrenzungsrahmen mit Labels versehen](md-localize-objects.md). Weitere Informationen finden Sie unter [Datensätzen einen Zweck geben](md-dataset-purpose.md).
## Hinzufügen eines Datensatzes zu einem Projekt (SDK)
Sie können einem vorhanden Projekt auf folgende Weise einen Trainings- oder Testdatensatz hinzufügen:
+ Erstellen eines Datensatzes unter Verwendung einer Manifestdatei. Weitere Informationen finden Sie unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Erstellen eines leeren Datensatzes und anschließendes Füllen des Datensatzes. Im folgenden Beispiel sehen Sie, wie ein leerer Datensatz erstellt wird: Informationen zum Hinzufügen von Einträgen, nachdem Sie einen leeren Datensatz erstellt haben, finden Sie unter [Weitere Bilder zu einem Datensatz hinzufügen](md-add-images.md).
**Topics**
**So fügen Sie einem Projekt einen Datensatz hinzu (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie den AWS CLI und den. AWS SDKs Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie die folgenden Beispiele, um einem Datensatz JSON-Zeilen hinzuzufügen.
------
#### [ CLI ]
Ersetzen Sie `project_arn` durch das Projekt, zu dem Sie den Datensatz hinzufügen möchten. Ersetzen Sie `dataset_type` durch `TRAIN`, um einen Trainingsdatensatz zu erstellen, oder durch `TEST`, um einen Testdatensatz zu erstellen.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type dataset_type \
--profile custom-labels-access
```
------
#### [ Python ]
Erstellen Sie einen Datensatz mit dem folgenden Code. Geben Sie die folgenden Befehlszeilenoptionen an:
+ `project_arn`— den ARN des Projekts, dem Sie den Testdatensatz hinzufügen möchten.
+ `type` — den Typ des Datensatzes, den Sie erstellen möchten (Trainieren oder Testen)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_empty_dataset(rek_client, project_arn, dataset_type):
"""
Creates an empty Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to create a dataset.
:param dataset_type: The type of the dataset that you want to create (train or test).
"""
try:
#Create the dataset.
logger.info("Creating empty %s dataset for project %s",
dataset_type, project_arn)
dataset_type=dataset_type.upper()
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type
)
dataset_arn=response['DatasetArn']
logger.info("dataset ARN: %s", dataset_arn)
finished=False
while finished is False:
dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
status=dataset['DatasetDescription']['Status']
if status == "CREATE_IN_PROGRESS":
logger.info(("Creating dataset: %s ", dataset_arn))
time.sleep(5)
continue
if status == "CREATE_COMPLETE":
logger.info("Dataset created: %s", dataset_arn)
finished=True
continue
if status == "CREATE_FAILED":
error_message = f"Dataset creation failed: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
error_message = f"Failed. Unexpected state for dataset creation: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
return dataset_arn
except ClientError as err:
logger.exception("Couldn't create dataset: %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 create the empty dataset."
)
parser.add_argument(
"dataset_type", help="The type of the empty dataset that you want to create (train or test)."
)
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"Creating empty {args.dataset_type} dataset for project {args.project_arn}")
# Create the empty dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
dataset_arn=create_empty_dataset(rekognition_client,
args.project_arn,
args.dataset_type.lower())
print(f"Finished creating empty dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating empty dataset: %s", err)
print(f"Problem creating empty dataset: {err}")
except Exception as err:
logger.exception("Problem creating empty dataset: %s", err)
print(f"Problem creating empty dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Erstellen Sie einen Datensatz mit dem folgenden Code. Geben Sie die folgenden Befehlszeilenoptionen an:
+ `project_arn`— den ARN des Projekts, dem Sie den Testdatensatz hinzufügen möchten.
+ `type` — den Typ des Datensatzes, den Sie erstellen möchten (Trainieren oder Testen)
```
/*
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.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DatasetType;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateEmptyDataset {
public static final Logger logger = Logger.getLogger(CreateEmptyDataset.class.getName());
public static String createMyEmptyDataset(RekognitionClient rekClient, String projectArn, String datasetType)
throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating empty {0} dataset for project : {1}",
new Object[] { datasetType.toString(), projectArn });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Unrecognized dataset type: {0}", datasetType);
throw new Exception("Unrecognized dataset type: " + datasetType);
}
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
//Wait until updates finishes
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(response.datasetArn()).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, "Creating dataset ARN: {0} ", response.datasetArn());
switch (status) {
case CREATE_COMPLETE:
logger.log(Level.INFO, "Dataset created");
created = true;
break;
case CREATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case CREATE_FAILED:
String error = "Dataset creation failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected creation state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (created == false);
return response.datasetArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not create dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String datasetType = null;
String datasetArn = null;
String projectArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - the ARN of the project that you want to add copy the datast to.\n\n"
+ " dataset_type - the type of the empty dataset that you want to create (train or test).\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
try {
// Get the Rekognition client
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Create the dataset
datasetArn = createMyEmptyDataset(rekClient, projectArn, datasetType);
System.out.println(String.format("Created dataset: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
1. Fügen Sie dem Datensatz Bilder hinzu. Weitere Informationen finden Sie unter [Weitere Bilder hinzufügen (SDK)](md-add-images.md#md-add-images-sdk).
# Weitere Bilder zu einem Datensatz hinzufügen
Sie können Ihren Datensätzen weitere Bilder hinzufügen, indem Sie die Amazon Rekognition Custom Labels-Konsole verwenden oder die `UpdateDatasetEntries`-API aufrufen.
**Topics**
+ [Weitere Bilder hinzufügen (Konsole)](#md-add-images-console)
+ [Weitere Bilder hinzufügen (SDK)](#md-add-images-sdk)
## Weitere Bilder hinzufügen (Konsole)
Wenn Sie die Amazon Rekognition Custom Labels-Konsole verwenden, laden Sie Bilder von Ihrem lokalen Computer hoch. Die Bilder werden dem Amazon-S3-Bucket-Speicherort (Konsole oder extern) hinzugefügt, wo die Bilder gespeichert werden, die zur Erstellung des Datensatzes verwendet wurden.
**So fügen Sie Ihrem Datensatz (Konsole) weitere Bilder hinzu**
1. Öffnen Sie die Amazon Rekognition Rekognition-Konsole unter. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Wählen Sie im linken Navigationsbereich **Custom Labels verwenden** aus. Die Landingpage von Amazon Rekognition Custom Labels wird angezeigt.
1. Wählen Sie im linken Navigationsbereich die Option **Projekte** aus. Die Projektansicht wird angezeigt.
1. Wählen Sie das Projekt aus, das Sie verwenden möchten.
1. Wählen Sie im linken Navigationsbereich unter dem Projektnamen **Datensatz** aus.
1. Wählen Sie **Aktionen** aus und wählen Sie den Datensatz aus, dem Sie Bilder hinzufügen möchten.
1. Wählen Sie die Bilder aus, die Sie in den Datensatz hochladen möchten. Sie können die Bilder ziehen oder die Bilder auswählen, die Sie von Ihrem lokalen Computer hochladen möchten. Sie können bis zu 30 Bilder gleichzeitig hochladen.
1. Wählen Sie **Bilder hochladen**.
1. Wählen Sie **Änderungen speichern ** aus.
1. Versehen Sie die Bilder mit Labels. Weitere Informationen finden Sie unter [Labeling von Bildern](md-labeling-images.md).
## Weitere Bilder hinzufügen (SDK)
`UpdateDatasetEntries` aktualisiert oder fügt JSON-Zeilen zu einer Manifestdatei hinzu. Sie übergeben die JSON-Zeilen als byte64-kodiertes Datenobjekt im `GroundTruth`-Feld. Wenn Sie ein AWS SDK zum Aufrufen verwenden`UpdateDatasetEntries`, codiert das SDK die Daten für Sie. Jede JSON-Zeile enthält Informationen für ein einzelnes Bild, z. B. zugewiesene Labels oder Begrenzungsrahmen-Informationen. Beispiel:
```
{"source-ref":"s3://bucket/image","BB":{"annotations":[{"left":1849,"top":1039,"width":422,"height":283,"class_id":0},{"left":1849,"top":1340,"width":443,"height":415,"class_id":1},{"left":2637,"top":1380,"width":676,"height":338,"class_id":2},{"left":2634,"top":1051,"width":673,"height":338,"class_id":3}],"image_size":[{"width":4000,"height":2667,"depth":3}]},"BB-metadata":{"job-name":"labeling-job/BB","class-map":{"0":"comparator","1":"pot_resistor","2":"ir_phototransistor","3":"ir_led"},"human-annotated":"yes","objects":[{"confidence":1},{"confidence":1},{"confidence":1},{"confidence":1}],"creation-date":"2021-06-22T10:11:18.006Z","type":"groundtruth/object-detection"}}
```
Weitere Informationen finden Sie unter [Erstellen einer Manifestdatei](md-create-manifest-file.md).
Verwenden Sie `source-ref` als Schlüssel, um Bilder zu identifizieren, die Sie aktualisieren möchten. Wenn der Datensatz keinen passenden `source-ref` Feldwert enthält, wird die JSON-Zeile als neues Bild hinzugefügt.
**So fügen Sie mehr Bilder zu einem Datensatz hinzu (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie die folgenden Beispiele, um einem Datensatz JSON-Zeilen hinzuzufügen.
------
#### [ CLI ]
Ersetzen Sie den Wert von `GroundTruth` durch die JSON-Zeilen, die Sie verwenden möchten. Sie müssen alle Sonderzeichen innerhalb der JSON-Zeile maskieren.
```
aws rekognition update-dataset-entries\
--dataset-arn dataset_arn \
--changes '{"GroundTruth" : "{\"source-ref\":\"s3://your_bucket/your_image\",\"BB\":{\"annotations\":[{\"left\":1776,\"top\":1017,\"width\":458,\"height\":317,\"class_id\":0},{\"left\":1797,\"top\":1334,\"width\":418,\"height\":415,\"class_id\":1},{\"left\":2597,\"top\":1361,\"width\":655,\"height\":329,\"class_id\":2},{\"left\":2581,\"top\":1020,\"width\":689,\"height\":338,\"class_id\":3}],\"image_size\":[{\"width\":4000,\"height\":2667,\"depth\":3}]},\"BB-metadata\":{\"job-name\":\"labeling-job/BB\",\"class-map\":{\"0\":\"comparator\",\"1\":\"pot_resistor\",\"2\":\"ir_phototransistor\",\"3\":\"ir_led\"},\"human-annotated\":\"yes\",\"objects\":[{\"confidence\":1},{\"confidence\":1},{\"confidence\":1},{\"confidence\":1}],\"creation-date\":\"2021-06-22T10:10:48.492Z\",\"type\":\"groundtruth/object-detection\"}}" }' \
--cli-binary-format raw-in-base64-out \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ dataset\$1arn `` — der ARN des Datensatzes, den Sie aktualisieren möchten.
+ updates\$1file `` — die Datei, die die JSON-Line-Updates enthält.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to add entries to an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def update_dataset_entries(rek_client, dataset_arn, updates_file):
"""
Adds dataset entries to an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataset that yuo want to update.
:param updates_file: The manifest file of JSON Lines that contains the updates.
"""
try:
status=""
status_message=""
# Update dataset entries.
logger.info("Updating dataset %s", dataset_arn)
with open(updates_file) as f:
manifest_file = f.read()
changes=json.loads('{ "GroundTruth" : ' +
json.dumps(manifest_file) +
'}')
rek_client.update_dataset_entries(
Changes=changes, DatasetArn=dataset_arn
)
finished=False
while finished is False:
dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
status=dataset['DatasetDescription']['Status']
status_message=dataset['DatasetDescription']['StatusMessage']
if status == "UPDATE_IN_PROGRESS":
logger.info("Updating dataset: %s ", dataset_arn)
time.sleep(5)
continue
if status == "UPDATE_COMPLETE":
logger.info("Dataset updated: %s : %s : %s",
status, status_message, dataset_arn)
finished=True
continue
if status == "UPDATE_FAILED":
error_message = f"Dataset update failed: {status} : {status_message} : {dataset_arn}"
logger.exception(error_message)
raise Exception (error_message)
error_message = f"Failed. Unexpected state for dataset update: {status} : {status_message} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
logger.info("Added entries to dataset")
return status, status_message
except ClientError as err:
logger.exception("Couldn't update dataset: %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(
"dataset_arn", help="The ARN of the dataset that you want to update."
)
parser.add_argument(
"updates_file", help="The manifest file of JSON Lines that contains the updates."
)
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"Updating dataset {args.dataset_arn} with entries from {args.updates_file}.")
# Update the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
status, status_message=update_dataset_entries(rekognition_client,
args.dataset_arn,
args.updates_file)
print(f"Finished updates dataset: {status} : {status_message}")
except ClientError as err:
logger.exception("Problem updating dataset: %s", err)
print(f"Problem updating dataset: {err}")
except Exception as err:
logger.exception("Problem updating dataset: %s", err)
print(f"Problem updating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
+ dataset\$1arn `` — der ARN des Datensatzes, den Sie aktualisieren möchten.
+ update\$1file `` — die Datei, die die JSON-Line-Updates enthält.
```
/*
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.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DatasetChanges;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.UpdateDatasetEntriesRequest;
import software.amazon.awssdk.services.rekognition.model.UpdateDatasetEntriesResponse;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
public class UpdateDatasetEntries {
public static final Logger logger = Logger.getLogger(UpdateDatasetEntries.class.getName());
public static String updateMyDataset(RekognitionClient rekClient, String datasetArn,
String updateFile
) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Updating dataset {0}",
new Object[] { datasetArn});
InputStream sourceStream = new FileInputStream(updateFile);
SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
DatasetChanges datasetChanges = DatasetChanges.builder()
.groundTruth(sourceBytes).build();
UpdateDatasetEntriesRequest updateDatasetEntriesRequest = UpdateDatasetEntriesRequest.builder()
.changes(datasetChanges)
.datasetArn(datasetArn)
.build();
UpdateDatasetEntriesResponse response = rekClient.updateDatasetEntries(updateDatasetEntriesRequest);
boolean updated = false;
//Wait until update completes
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(datasetArn).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, " dataset ARN: {0} ", datasetArn);
switch (status) {
case UPDATE_COMPLETE:
logger.log(Level.INFO, "Dataset updated");
updated = true;
break;
case UPDATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case UPDATE_FAILED:
String error = "Dataset update failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected update state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (updated == false);
return datasetArn;
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not update dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String updatesFile = null;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " dataset_arn - the ARN of the dataset that you want to update.\n\n"
+ " update_file - The file that includes in JSON Line updates.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
datasetArn = args[0];
updatesFile = args[1];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Update the dataset
datasetArn = updateMyDataset(rekClient, datasetArn, updatesFile);
System.out.println(String.format("Dataset updated: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Erstellen eines Datensatzes mit einem vorhandenen Datensatz (SDK)
Das folgende Verfahren zeigt Ihnen, wie Sie mithilfe der [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)Operation einen Datensatz aus einem vorhandenen Datensatz erstellen.
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie den AWS CLI und den AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie den folgenden Beispielcode, um einen Datensatz zu erstellen, indem Sie einen anderen Datensatz kopieren.
------
#### [ AWS CLI ]
Erstellen Sie den Datensatz mit dem folgenden Code. Ersetzen Sie Folgendes:
+ `project_arn`— den ARN des Projekts, dem Sie den Datensatz hinzufügen möchten.
+ `dataset_type`— mit dem Typ des Datensatzes (`TRAIN` oder `TEST`), den Sie im Projekt erstellen möchten.
+ `dataset_arn`— mit dem ARN des Datensatzes, den Sie kopieren möchten.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type dataset_type \
--dataset-source '{ "DatasetArn" : "dataset_arn" }' \
--profile custom-labels-access
```
------
#### [ Python ]
Im folgenden Beispiel wird ein Datensatz mithilfe einem vorhandenen Datensatz erstellt und deren ARN angezeigt.
Geben Sie die folgenden Befehlszeilenargumente an, um das Programm auszuführen:
+ `project_arn`— den ARN des Projekts, das Sie verwenden möchten.
+ `dataset_type`— der Typ des Projektdatensatzes, den Sie erstellen möchten (`train` oder `test`).
+ `dataset_arn`— den ARN des Datensatzes, aus dem Sie den Datensatz erstellen möchten.
```
# 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 time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_dataset_from_existing_dataset(rek_client, project_arn, dataset_type, dataset_arn):
"""
Creates an Amazon Rekognition Custom Labels dataset using an existing dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to create a dataset.
:param dataset_type: The type of the dataset that you want to create (train or test).
:param dataset_arn: The ARN of the existing dataset that you want to use.
"""
try:
# Create the dataset
dataset_type=dataset_type.upper()
logger.info(
"Creating %s dataset for project %s from dataset %s.",
dataset_type,project_arn, dataset_arn)
dataset_source = json.loads(
'{ "DatasetArn": "' + dataset_arn + '"}'
)
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
)
dataset_arn = response['DatasetArn']
logger.info("New dataset ARN: %s", dataset_arn)
finished = False
while finished is False:
dataset = rek_client.describe_dataset(DatasetArn=dataset_arn)
status = dataset['DatasetDescription']['Status']
if status == "CREATE_IN_PROGRESS":
logger.info(("Creating dataset: %s ", dataset_arn))
time.sleep(5)
continue
if status == "CREATE_COMPLETE":
logger.info("Dataset created: %s", dataset_arn)
finished = True
continue
if status == "CREATE_FAILED":
error_message = f"Dataset creation failed: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
error_message = f"Failed. Unexpected state for dataset creation: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
return dataset_arn
except ClientError as err:
logger.exception(
"Couldn't create dataset: %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 create the dataset."
)
parser.add_argument(
"dataset_type", help="The type of the dataset that you want to create (train or test)."
)
parser.add_argument(
"dataset_arn", help="The ARN of the dataset that you want to copy from."
)
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"Creating {args.dataset_type} dataset for project {args.project_arn}")
# Create the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
dataset_arn = create_dataset_from_existing_dataset(rekognition_client,
args.project_arn,
args.dataset_type,
args.dataset_arn)
print(f"Finished creating dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
except Exception as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Im folgenden Beispiel wird ein Datensatz mithilfe einem vorhandenen Datensatz erstellt und deren ARN angezeigt.
Geben Sie die folgenden Befehlszeilenargumente an, um das Programm auszuführen:
+ `project_arn`— den ARN des Projekts, das Sie verwenden möchten.
+ `dataset_type`— der Typ des Projektdatensatzes, den Sie erstellen möchten (`train` oder `test`).
+ `dataset_arn`— den ARN des Datensatzes, aus dem Sie den Datensatz erstellen möchten.
```
/*
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.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetSource;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DatasetType;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateDatasetExisting {
public static final Logger logger = Logger.getLogger(CreateDatasetExisting.class.getName());
public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
String existingDatasetArn) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating {0} dataset for project : {1} from dataset {2} ",
new Object[] { datasetType.toString(), projectArn, existingDatasetArn });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Unrecognized dataset type: {0}", datasetType);
throw new Exception("Unrecognized dataset type: " + datasetType);
}
DatasetSource datasetSource = DatasetSource.builder().datasetArn(existingDatasetArn).build();
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).datasetSource(datasetSource).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
//Wait until create finishes
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(response.datasetArn()).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, "Creating dataset ARN: {0} ", response.datasetArn());
switch (status) {
case CREATE_COMPLETE:
logger.log(Level.INFO, "Dataset created");
created = true;
break;
case CREATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case CREATE_FAILED:
String error = "Dataset creation failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected creation state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (created == false);
return response.datasetArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not create dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String datasetType = null;
String datasetArn = null;
String projectArn = null;
String datasetSourceArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - the ARN of the project that you want to add copy the datast to.\n\n"
+ " dataset_type - the type of the dataset that you want to create (train or test).\n\n"
+ " dataset_arn - the ARN of the dataset that you want to copy from.\n\n";
if (args.length != 3) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
datasetSourceArn = args[2];
try {
// Get the Rekognition client
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Create the dataset
datasetArn = createMyDataset(rekClient, projectArn, datasetType, datasetSourceArn);
System.out.println(String.format("Created dataset: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Beschreibung eines Datensatzes (SDK)
Sie können die `DescribeDataset`-API verwenden, um Informationen über einen Datensatz abzurufen.
**So beschreiben Sie einen Datensatz (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie den folgenden Beispielcode, um einen Datensatz zu beschreiben.
------
#### [ AWS CLI ]
Ändern Sie den Wert von `dataset-arn` in den ARN des Datensatzes, den Sie beschreiben möchten.
```
aws rekognition describe-dataset --dataset-arn dataset_arn \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ dataset\$1arn — der ARN des Datensatzes, den Sie beschreiben möchten.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to describe an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def describe_dataset(rek_client, dataset_arn):
"""
Describes an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataset that you want to describe.
"""
try:
# Describe the dataset
logger.info("Describing dataset %s", dataset_arn)
dataset = rek_client.describe_dataset(DatasetArn=dataset_arn)
description = dataset['DatasetDescription']
print(f"Created: {str(description['CreationTimestamp'])}")
print(f"Updated: {str(description['LastUpdatedTimestamp'])}")
print(f"Status: {description['Status']}")
print(f"Status message: {description['StatusMessage']}")
print(f"Status code: {description['StatusMessageCode']}")
print("Stats:")
print(
f"\tLabeled entries: {description['DatasetStats']['LabeledEntries']}")
print(
f"\tTotal entries: {description['DatasetStats']['TotalEntries']}")
print(f"\tTotal labels: {description['DatasetStats']['TotalLabels']}")
except ClientError as err:
logger.exception("Couldn't describe dataset: %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(
"dataset_arn", help="The ARN of the dataset that you want to describe."
)
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"Describing dataset {args.dataset_arn}")
# Describe the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
describe_dataset(rekognition_client, args.dataset_arn)
print(f"Finished describing dataset: {args.dataset_arn}")
except ClientError as err:
error_message=f"Problem describing dataset: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem describing dataset: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
+ dataset\$1arn — der ARN des Datensatzes, den Sie beschreiben möchten.
```
/*
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.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStats;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class DescribeDataset {
public static final Logger logger = Logger.getLogger(DescribeDataset.class.getName());
public static void describeMyDataset(RekognitionClient rekClient, String datasetArn) {
try {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder().datasetArn(datasetArn)
.build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStats datasetStats = datasetDescription.datasetStats();
System.out.println("ARN: " + datasetArn);
System.out.println("Created: " + datasetDescription.creationTimestamp().toString());
System.out.println("Updated: " + datasetDescription.lastUpdatedTimestamp().toString());
System.out.println("Status: " + datasetDescription.statusAsString());
System.out.println("Message: " + datasetDescription.statusMessage());
System.out.println("Total Labels: " + datasetStats.totalLabels().toString());
System.out.println("Total entries: " + datasetStats.totalEntries().toString());
System.out.println("Entries with labels: " + datasetStats.labeledEntries().toString());
System.out.println("Entries with at least 1 error: " + datasetStats.errorEntries().toString());
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
throw rekError;
}
}
public static void main(String[] args) {
final String USAGE = "\n" + "Usage: " + "\n\n" + "Where:\n"
+ " dataset_arn - The ARN of the dataset that you want to describe.\n\n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String datasetArn = args[0];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Describe the dataset.
describeMyDataset(rekClient, datasetArn);
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Auflisten von Datensatzeinträgen (SDK)
Sie können die `ListDatasetEntries`-API verwenden, um die JSON-Zeilen für jedes Bild in einem Datensatz aufzulisten. Weitere Informationen finden Sie unter [Erstellen einer Manifestdatei](md-create-manifest-file.md).
**So listen Sie Datensatzeinträge auf (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie den folgenden Beispielcode, um die Einträge in einem Datensatz aufzulisten
------
#### [ AWS CLI ]
Ändern Sie den Wert von `dataset-arn` in den ARN des Datensatzes, den Sie auflisten möchten.
```
aws rekognition list-dataset-entries --dataset-arn dataset_arn \
--profile custom-labels-access
```
Um nur fehlerhafte JSON-Zeilen aufzulisten, geben Sie `has-errors` an.
```
aws rekognition list-dataset-entries --dataset-arn dataset_arn \
--has-errors \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ dataset\$1arn — der ARN des Datensatzes, den Sie auflisten möchten.
+ show\$1errors\$1only — geben Sie `true` an, wenn Sie nur Fehler sehen möchten. `false` andernfalls.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to list the entries in an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def list_dataset_entries(rek_client, dataset_arn, show_errors):
"""
Lists the entries in an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataet that you want to use.
"""
try:
# List the entries.
logger.info("Listing dataset entries for the dataset %s.", dataset_arn)
finished = False
count = 0
next_token = ""
show_errors_only = False
if show_errors.lower() == "true":
show_errors_only = True
while finished is False:
response = rek_client.list_dataset_entries(
DatasetArn=dataset_arn,
HasErrors=show_errors_only,
MaxResults=100,
NextToken=next_token)
count += len(response['DatasetEntries'])
for entry in response['DatasetEntries']:
print(entry)
if 'NextToken' not in response:
finished = True
logger.info("No more entries. Total:%s", count)
else:
next_token = next_token = response['NextToken']
logger.info("Getting more entries. Total so far :%s", count)
except ClientError as err:
logger.exception(
"Couldn't list dataset: %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(
"dataset_arn", help="The ARN of the dataset that you want to list."
)
parser.add_argument(
"show_errors_only", help="true if you want to see errors only. false otherwise."
)
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"Listing entries for dataset {args.dataset_arn}")
# List the dataset entries.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
list_dataset_entries(rekognition_client,
args.dataset_arn,
args.show_errors_only)
print(f"Finished listing entries for dataset: {args.dataset_arn}")
except ClientError as err:
error_message = f"Problem listing dataset: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem listing dataset: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ dataset\$1arn — der ARN des Datensatzes, den Sie auflisten möchten.
+ show\$1errors\$1only — geben Sie `true` an, wenn Sie nur Fehler sehen möchten. `false` andernfalls.
```
/*
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.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.ListDatasetEntriesRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.paginators.ListDatasetEntriesIterable;
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ListDatasetEntries {
public static final Logger logger = Logger.getLogger(ListDatasetEntries.class.getName());
public static void listMyDatasetEntries(RekognitionClient rekClient, String datasetArn, boolean showErrorsOnly)
throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Listing dataset {0}", new Object[] { datasetArn });
ListDatasetEntriesRequest listDatasetEntriesRequest = ListDatasetEntriesRequest.builder()
.hasErrors(showErrorsOnly).datasetArn(datasetArn).maxResults(1).build();
ListDatasetEntriesIterable datasetEntriesList = rekClient
.listDatasetEntriesPaginator(listDatasetEntriesRequest);
datasetEntriesList.stream().flatMap(r -> r.datasetEntries().stream())
.forEach(datasetEntry -> System.out.println(datasetEntry.toString()));
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not update dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
boolean showErrorsOnly = false;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " dataset_arn - the ARN of the dataset that you want to update.\n\n"
+ " show_errors_only - true to show only errors. false otherwise.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
datasetArn = args[0];
if (args[1].toLowerCase().equals("true")) {
showErrorsOnly = true;
}
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// list the dataset entries.
listMyDatasetEntries(rekClient, datasetArn, showErrorsOnly);
System.out.println(String.format("Finished listing entries for : %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Verteilen eines Trainingsdatensatzes (SDK)
Amazon Rekognition Custom Labels benötigt einen Trainingsdatensatz und einen Testdatensatz, um Ihr Modell zu trainieren.
Wenn Sie die API verwenden, können Sie die [DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries)API verwenden, um 20% des Trainingsdatensatzes in einen leeren Testdatensatz zu verteilen. Die Verteilung des Trainingsdatensatzes kann nützlich sein, wenn Sie nur eine einzige Manifestdatei zur Verfügung haben. Verwenden Sie die einzelne Manifestdatei, um Ihren Trainingsdatensatz zu erstellen. Erstellen Sie dann einen leeren Testdatensatz und verwenden Sie `DistributeDatasetEntries`, um den Testdatensatz aufzufüllen.
**Anmerkung**
Wenn Sie die Amazon Rekognition Custom Labels-Konsole verwenden und mit einem einzelnen Datensatzprojekt beginnen, teilt Amazon Rekognition Custom Labels den Trainingsdatensatz während des Trainings auf, um einen Testdatensatz zu erstellen. 20 % der Trainingsdatensatzeinträge werden in den Testdatensatz verschoben.
**So verteilen Sie einen Trainingsdatensatz (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie den AWS CLI und den AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Ein Projekt zu erstellen. Weitere Informationen finden Sie unter [Erstellen eines neuen Amazon Rekognition Custom Labels-Projekts (SDK)](mp-create-project.md#mp-create-project-sdk).
1. Erstellen Ihres Trainingsdatensatzes. Weitere Informationen zu Datensatz finden Sie unter [Trainings- und Testdatensätze erstellen](creating-datasets.md).
1. Erstellen eines leeren Testdatensatzes.
1. Verwenden Sie den folgenden Beispielcode, um 20 % der Trainingsdatensatzeinträge auf den Testdatensatz zu verteilen. Sie können die Amazon Resource Names (ARN) für die Datensätze eines Projekts abrufen, indem Sie anrufen [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjects). Einen Beispielcode finden Sie unter [Beschreibung eines Projekts (SDK)](md-describing-project-sdk.md).
------
#### [ AWS CLI ]
Ändern Sie den Wert von `training_dataset-arn` und `test_dataset_arn` mit den ARNs der Datensätze, die Sie verwenden möchten.
```
aws rekognition distribute-dataset-entries --datasets ['{"Arn": "training_dataset_arn"}, {"Arn": "test_dataset_arn"}'] \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ training\$1dataset\$1arn — der ARN des Trainingsdatensatzes, aus dem Sie Einträge verteilen.
+ test\$1dataset\$1arn — der ARN des Testdatensatzes, an den Sie Einträge verteilen.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def check_dataset_status(rek_client, dataset_arn):
"""
Checks the current status of a dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The dataset that you want to check.
:return: The dataset status and status message.
"""
finished = False
status = ""
status_message = ""
while finished is False:
dataset = rek_client.describe_dataset(DatasetArn=dataset_arn)
status = dataset['DatasetDescription']['Status']
status_message = dataset['DatasetDescription']['StatusMessage']
if status == "UPDATE_IN_PROGRESS":
logger.info("Distributing dataset: %s ", dataset_arn)
time.sleep(5)
continue
if status == "UPDATE_COMPLETE":
logger.info(
"Dataset distribution complete: %s : %s : %s",
status, status_message, dataset_arn)
finished = True
continue
if status == "UPDATE_FAILED":
logger.exception(
"Dataset distribution failed: %s : %s : %s",
status, status_message, dataset_arn)
finished = True
break
logger.exception(
"Failed. Unexpected state for dataset distribution: %s : %s : %s",
status, status_message, dataset_arn)
finished = True
status_message = "An unexpected error occurred while distributing the dataset"
break
return status, status_message
def distribute_dataset_entries(rek_client, training_dataset_arn, test_dataset_arn):
"""
Distributes 20% of the supplied training dataset into the supplied test dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param training_dataset_arn: The ARN of the training dataset that you distribute entries from.
:param test_dataset_arn: The ARN of the test dataset that you distribute entries to.
"""
try:
# List dataset labels.
logger.info("Distributing training dataset entries (%s) into test dataset (%s).",
training_dataset_arn,test_dataset_arn)
datasets = json.loads(
'[{"Arn" : "' + str(training_dataset_arn) + '"},{"Arn" : "' + str(test_dataset_arn) + '"}]')
rek_client.distribute_dataset_entries(
Datasets=datasets
)
training_dataset_status, training_dataset_status_message = check_dataset_status(
rek_client, training_dataset_arn)
test_dataset_status, test_dataset_status_message = check_dataset_status(
rek_client, test_dataset_arn)
if training_dataset_status == 'UPDATE_COMPLETE' and test_dataset_status == "UPDATE_COMPLETE":
print("Distribution complete")
else:
print("Distribution failed:")
print(
f"\ttraining dataset: {training_dataset_status} : {training_dataset_status_message}")
print(
f"\ttest dataset: {test_dataset_status} : {test_dataset_status_message}")
except ClientError as err:
logger.exception(
"Couldn't distribute dataset: %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(
"training_dataset_arn", help="The ARN of the training dataset that you want to distribute from."
)
parser.add_argument(
"test_dataset_arn", help="The ARN of the test dataset that you want to distribute to."
)
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"Distributing training dataset entries ({args.training_dataset_arn}) "\
f"into test dataset ({args.test_dataset_arn}).")
# Distribute the datasets.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
distribute_dataset_entries(rekognition_client,
args.training_dataset_arn,
args.test_dataset_arn)
print("Finished distributing datasets.")
except ClientError as err:
logger.exception("Problem distributing datasets: %s", err)
print(f"Problem listing dataset labels: {err}")
except Exception as err:
logger.exception("Problem distributing datasets: %s", err)
print(f"Problem distributing datasets: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ training\$1dataset\$1arn — der ARN des Trainingsdatensatzes, aus dem Sie Einträge verteilen.
+ test\$1dataset\$1arn — der ARN des Testdatensatzes, an den Sie Einträge verteilen.
```
/*
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.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DistributeDataset;
import software.amazon.awssdk.services.rekognition.model.DistributeDatasetEntriesRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
public class DistributeDatasetEntries {
public static final Logger logger = Logger.getLogger(DistributeDatasetEntries.class.getName());
public static DatasetStatus checkDatasetStatus(RekognitionClient rekClient, String datasetArn)
throws Exception, RekognitionException {
boolean distributed = false;
DatasetStatus status = null;
// Wait until distribution completes
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder().datasetArn(datasetArn)
.build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
status = datasetDescription.status();
logger.log(Level.INFO, " dataset ARN: {0} ", datasetArn);
switch (status) {
case UPDATE_COMPLETE:
logger.log(Level.INFO, "Dataset updated");
distributed = true;
break;
case UPDATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case UPDATE_FAILED:
String error = "Dataset distribution failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, error);
break;
default:
String unexpectedError = "Unexpected distribution state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, unexpectedError);
}
} while (distributed == false);
return status;
}
public static void distributeMyDatasetEntries(RekognitionClient rekClient, String trainingDatasetArn,
String testDatasetArn) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Distributing {0} dataset to {1} ",
new Object[] { trainingDatasetArn, testDatasetArn });
DistributeDataset distributeTrainingDataset = DistributeDataset.builder().arn(trainingDatasetArn).build();
DistributeDataset distributeTestDataset = DistributeDataset.builder().arn(testDatasetArn).build();
ArrayList datasets = new ArrayList();
datasets.add(distributeTrainingDataset);
datasets.add(distributeTestDataset);
DistributeDatasetEntriesRequest distributeDatasetEntriesRequest = DistributeDatasetEntriesRequest.builder()
.datasets(datasets).build();
rekClient.distributeDatasetEntries(distributeDatasetEntriesRequest);
DatasetStatus trainingStatus = checkDatasetStatus(rekClient, trainingDatasetArn);
DatasetStatus testStatus = checkDatasetStatus(rekClient, testDatasetArn);
if (trainingStatus == DatasetStatus.UPDATE_COMPLETE && testStatus == DatasetStatus.UPDATE_COMPLETE) {
logger.log(Level.INFO, "Successfully distributed dataset: {0}", trainingDatasetArn);
} else {
throw new Exception("Failed to distribute dataset: " + trainingDatasetArn);
}
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not distribute dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String trainingDatasetArn = null;
String testDatasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " training_dataset_arn - the ARN of the dataset that you want to distribute from.\n\n"
+ " test_dataset_arn - the ARN of the dataset that you want to distribute to.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
trainingDatasetArn = args[0];
testDatasetArn = args[1];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Distribute the dataset
distributeMyDatasetEntries(rekClient, trainingDatasetArn, testDatasetArn);
System.out.println("Datasets distributed.");
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Löschen eines Datensatzes
Sie können die Trainings- und Testdatensätze aus einem Projekt löschen.
**Topics**
+ [Löschen eines Datensatzes (Konsole)](#md-delete-dataset-console)
+ [Löschen eines Amazon Rekognition Custom Labels-Datensatzes (SDK)](#md-delete-dataset-sdk)
## Löschen eines Datensatzes (Konsole)
Führen Sie die folgenden Schritte aus, um einen Datensatz zu löschen. Wenn für das Projekt noch ein Datensatz übrig ist (Training oder Test), wird anschließend die Seite mit den Projektdetails angezeigt. Wenn das Projekt keine verbleibenden Datensätze hat, wird die Seite **Datensatz erstellen** angezeigt.
Wenn Sie den Trainingsdatensatz löschen, müssen Sie einen neuen Trainingsdatensatz für das Projekt erstellen, bevor Sie ein Modell trainieren können. Weitere Informationen finden Sie unter [Erstellen von Trainings- und Testdatensätzen mit Bildern](md-create-dataset.md).
Wenn Sie den Testdatensatz löschen, können Sie ein Modell trainieren, ohne einen neuen Testdatensatz zu erstellen. Während des Trainings wird der Trainingsdatensatz aufgeteilt, um einen neuen Testdatensatz für das Projekt zu erstellen. Durch die Aufteilung des Trainingsdatensatzes wird die Anzahl der für das Training verfügbaren Bilder reduziert. Um die Qualität aufrechtzuerhalten, empfehlen wir, vor dem Training eines Modells einen neuen Testdatensatz zu erstellen. Weitere Informationen finden Sie unter [Einen Datensatz zu einem Projekt hinzufügen](md-add-dataset.md).
**So löschen Sie einen Datensatz**
1. Öffnen Sie die Amazon Rekognition Rekognition-Konsole unter. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Wählen Sie im linken Navigationsbereich **Custom Labels verwenden** aus. Die Landingpage von Amazon Rekognition Custom Labels wird angezeigt.
1. Wählen Sie im linken Navigationsbereich die Option **Projekte** aus. Die Projektansicht wird angezeigt.
1. Wählen Sie das Projekt aus, das den Datensatz enthält, den Sie löschen möchten.
1. Wählen Sie im linken Navigationsbereich unter dem Projektnamen **Datensatz** aus
1. Wählen Sie **Aktionen**.
1. Um den Trainingsdatensatz zu löschen, wählen Sie **Trainingsdatensatz löschen.**
1. Um den Testdatensatz zu löschen, wählen Sie **Testdatensatz löschen.**
1. Geben Sie im Dialogfeld ***Trainings- oder Testdatensatz löschen*** **Löschen** ein, um zu bestätigen, dass Sie den Datensatz löschen möchten.
1. Wählen Sie ***Trainings- oder Testdatensatz löschen***, um den Datensatz zu löschen.
## Löschen eines Amazon Rekognition Custom Labels-Datensatzes (SDK)
Sie löschen einen Amazon Rekognition Custom Labels-Datensatz, indem Sie den Amazon-Ressourcennamen (ARN) des Datensatzes, den Sie löschen möchten, aufrufen [DeleteDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteDataset)und angeben. Rufen Sie an, um ARNs die Trainings- und Testdatensätze innerhalb eines Projekts abzurufen. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjects) Die Antwort umfasst eine Reihe von [ProjectDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectDescription)Objekten. Der Datensatz ARNs (`DatasetArn`) und die Datensatztypen (`DatasetType`) sind in der `Datasets` Liste enthalten.
Wenn Sie den Trainingsdatensatz löschen, müssen Sie einen neuen Trainingsdatensatz für das Projekt erstellen, bevor Sie ein Modell trainieren können. Wenn Sie den Testdatensatz löschen, müssen Sie einen neuen Testdatensatz erstellen, bevor Sie das Modell trainieren können. Weitere Informationen finden Sie unter [Hinzufügen eines Datensatzes zu einem Projekt (SDK)](md-add-dataset.md#md-add-dataset-sdk).
**Um einen Datensatz zu löschen (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie den AWS CLI und den AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie den folgenden Code, um einen Datensatz zu löschen.
------
#### [ AWS CLI ]
Ändern Sie den Wert von `dataset-arn` in den ARN des Datensatzes, den Sie löschen möchten.
```
aws rekognition delete-dataset --dataset-arn dataset-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ dataset\$1arn — der ARN des Datensatzes, den Sie löschen möchten.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to delete an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def delete_dataset(rek_client, dataset_arn):
"""
Deletes an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataset that you want to delete.
"""
try:
# Delete the dataset,
logger.info("Deleting dataset: %s", dataset_arn)
rek_client.delete_dataset(DatasetArn=dataset_arn)
deleted = False
logger.info("waiting for dataset deletion %s", dataset_arn)
# Dataset might not be deleted yet, so wait.
while deleted is False:
try:
rek_client.describe_dataset(DatasetArn=dataset_arn)
time.sleep(5)
except ClientError as err:
if err.response['Error']['Code'] == 'ResourceNotFoundException':
logger.info("dataset deleted: %s", dataset_arn)
deleted = True
else:
raise
logger.info("dataset deleted: %s", dataset_arn)
return True
except ClientError as err:
logger.exception("Couldn't delete dataset - %s: %s",
dataset_arn, 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(
"dataset_arn", help="The ARN of the dataset that you want to delete."
)
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"Deleting dataset: {args.dataset_arn}")
# Delete the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
delete_dataset(rekognition_client,
args.dataset_arn)
print(f"Finished deleting dataset: {args.dataset_arn}")
except ClientError as err:
error_message = f"Problem deleting dataset: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ dataset\$1arn — der ARN des Datensatzes, den Sie löschen möchten.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.util.logging.Level;
import java.util.logging.Logger;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DeleteDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DeleteDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class DeleteDataset {
public static final Logger logger = Logger.getLogger(DeleteDataset.class.getName());
public static void deleteMyDataset(RekognitionClient rekClient, String datasetArn) throws InterruptedException {
try {
logger.log(Level.INFO, "Deleting dataset: {0}", datasetArn);
// Delete the dataset
DeleteDatasetRequest deleteDatasetRequest = DeleteDatasetRequest.builder().datasetArn(datasetArn).build();
DeleteDatasetResponse response = rekClient.deleteDataset(deleteDatasetRequest);
// Wait until deletion finishes
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder().datasetArn(datasetArn)
.build();
Boolean deleted = false;
do {
try {
rekClient.describeDataset(describeDatasetRequest);
Thread.sleep(5000);
} catch (RekognitionException e) {
String errorCode = e.awsErrorDetails().errorCode();
if (errorCode.equals("ResourceNotFoundException")) {
logger.log(Level.INFO, "Dataset deleted: {0}", datasetArn);
deleted = true;
} else {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
} while (Boolean.FALSE.equals(deleted));
logger.log(Level.INFO, "Dataset deleted: {0} ", datasetArn);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + "\n\n" + "Where:\n"
+ " dataset_arn - The ARN of the dataset that you want to delete.\n\n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String datasetArn = args[0];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Delete the dataset
deleteMyDataset(rekClient, datasetArn);
System.out.println(String.format("Dataset deleted: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------