Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Gestione di set di dati
Un set di dati contiene le immagini e le etichette assegnate utilizzate per addestrare o testare un modello. Gli argomenti di questa sezione mostrano come gestire un set di dati con la console Amazon Rekognition Custom Labels e l'SDK. AWS
**Topics**
+ [Aggiungere un set di dati a un progetto](md-add-dataset.md)
+ [Aggiungere altre immagini a un set di dati](md-add-images.md)
+ [Creazione di un set di dati utilizzando un set di dati esistente (SDK)](md-create-dataset-existing-dataset-sdk.md)
+ [Descrizione di un set di dati (SDK)](md-describing-dataset-sdk.md)
+ [Elencare le voci del set di dati (SDK)](md-listing-dataset-entries-sdk.md)
+ [Distribuzione di un set di dati di addestramento (SDK)](md-distributing-datasets.md)
+ [Eliminazione di un set di dati](md-delete-dataset.md)
# Aggiungere un set di dati a un progetto
È possibile aggiungere un set di dati di addestramento o un set di dati di test a un progetto esistente. Se desideri sostituire un set di dati esistente, elimina prima il set di dati esistente. Per ulteriori informazioni, consulta [Eliminazione di un set di dati](md-delete-dataset.md). Quindi aggiungi il nuovo set di dati.
**Topics**
+ [Aggiungere un set di dati a un progetto (Console)](#md-add-dataset-console)
+ [Aggiungere un set di dati a un progetto (SDK)](#md-add-dataset-sdk)
## Aggiungere un set di dati a un progetto (Console)
Puoi aggiungere un set di dati di addestramento o di test a un progetto utilizzando la console di Amazon Rekognition Custom Labels.
**Aggiungere un set di dati a un progetto**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Nel riquadro a sinistra, scegli **Usa etichette personalizzate**. Viene visualizzata la pagina iniziale di Amazon Rekognition Custom Labels.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**. Viene visualizzata la vista Progetti.
1. Scegli il progetto a cui desideri aggiungere un set di dati.
1. Nel pannello di navigazione a sinistra, sotto il nome del progetto, scegli **Set di dati**.
1. Se il progetto non ha un set di dati esistente, viene visualizzata la pagina **Crea set di dati**. Esegui questa operazione:
1. Nella pagina **Crea set di dati**, inserisci le informazioni sull’origine dell'immagine. Per ulteriori informazioni, consulta [Creazione di set di dati di addestramento e test con immagini](md-create-dataset.md).
1. Scegli **Crea set di dati** per creare il set di dati.
1. Se il progetto ha un set di dati esistente (di addestramento o di test), viene visualizzata la pagina dei dettagli del progetto. Esegui questa operazione:
1. Nella pagina dei dettagli del progetto, scegli **Azioni**.
1. Se desideri aggiungere un set di dati di addestramento, scegli **Crea set di dati di addestramento**.
1. Se desideri aggiungere un set di dati di test, scegli **Crea set di dati di test**.
1. Nella pagina **Crea set di dati**, inserisci le informazioni sull’origine dell'immagine. Per ulteriori informazioni, consulta [Creazione di set di dati di addestramento e test con immagini](md-create-dataset.md).
1. Scegli **Crea set di dati** per creare il set di dati.
1. Aggiungi immagini al tuo set di dati. Per ulteriori informazioni, consulta [Aggiungere altre immagini (console)](md-add-images.md#md-add-images-console).
1. Aggiungi etichette al tuo set di dati. Per ulteriori informazioni, consulta [Aggiungere nuove etichette (Console)](md-labels.md#md-add-new-labels).
1. Aggiungi etichette alle tue immagini. Se stai aggiungendo etichette a livello di immagine, consulta [Assegnazione di etichette a livello di immagine a un'immagine](md-assign-image-level-labels.md). Se stai aggiungendo riquadri di delimitazione, vedi [Etichettatura degli oggetti con riquadri di delimitazione](md-localize-objects.md). Per ulteriori informazioni, consulta [Formattazione di set di dati](md-dataset-purpose.md).
## Aggiungere un set di dati a un progetto (SDK)
È possibile aggiungere un set di dati di addestramento o di test a un progetto esistente nei seguenti modi:
+ Crea un set di dati utilizzando un file manifest. Per ulteriori informazioni, consulta [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Crea un set di dati vuoto e popola il set di dati in seguito. Il seguente esempio illustra come creare un set di dati vuoto. Per aggiungere voci dopo aver creato un set di dati vuoto, vedi [Aggiungere altre immagini a un set di dati](md-add-images.md).
**Topics**
**Per aggiungere un set di dati a un progetto (SDK)**
1. Se non l'hai ancora fatto, installa e configura il e il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Usa i seguenti esempi per aggiungere righe JSON a un set di dati.
------
#### [ CLI ]
Sostituire `project_arn` con il progetto a cui desideri aggiungere il set di dati. Sostituisci `dataset_type` con `TRAIN` per creare un set di dati di addestramento o con `TEST` per creare un set di dati di test.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type dataset_type \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice per creare un set di dati. Fornisci le seguenti opzioni di riga di comando:
+ `project_arn` — l'ARN del progetto a cui si desidera aggiungere il set di dati di test.
+ `type`— il tipo di set di dati che desideri creare (di addestramento o di test)
```
# 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 ]
Usa il seguente codice per creare un set di dati. Fornisci le seguenti opzioni di riga di comando:
+ `project_arn` — l'ARN del progetto a cui si desidera aggiungere il set di dati di test.
+ `type`— il tipo di set di dati che desideri creare (di addestramento o di test)
```
/*
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. Aggiungi immagini al set di dati. Per ulteriori informazioni, consulta [Aggiungere altre immagini (SDK)](md-add-images.md#md-add-images-sdk).
# Aggiungere altre immagini a un set di dati
Puoi aggiungere altre immagini ai tuoi set di dati utilizzando la console di Amazon Rekognition Custom Labels o chiamando l'API `UpdateDatasetEntries`.
**Topics**
+ [Aggiungere altre immagini (console)](#md-add-images-console)
+ [Aggiungere altre immagini (SDK)](#md-add-images-sdk)
## Aggiungere altre immagini (console)
Quando usi la console di Amazon Rekognition Custom Labels, carichi immagini dal tuo computer locale. Le immagini vengono aggiunte alla posizione del bucket Amazon S3 (console o esterno) in cui sono archiviate le immagini utilizzate per creare il set di dati.
**Per aggiungere altre immagini al set di dati (console)**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Nel riquadro a sinistra, scegli **Usa etichette personalizzate**. Viene visualizzata la pagina iniziale di Amazon Rekognition Custom Labels.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**. Viene visualizzata la vista Progetti.
1. Scegli il progetto che desideri usare.
1. Nel pannello di navigazione a sinistra, sotto il nome del progetto, scegli **Set di dati**.
1. Scegli **Azioni** e seleziona il set di dati a cui desideri aggiungere immagini.
1. Scegli le immagini che desideri caricare nel set di dati. Puoi trascinare le immagini o scegliere le immagini che desideri caricare dal tuo computer locale. Puoi caricare fino a 30 immagini alla volta.
1. Scegli **Carica immagini**.
1. Scegli **Save changes** (Salva modifiche).
1. Etichetta le immagini. Per ulteriori informazioni, consulta [Immagini etichettate](md-labeling-images.md).
## Aggiungere altre immagini (SDK)
`UpdateDatasetEntries` aggiorna o aggiunge righe JSON a un file manifest. Le righe JSON vengono trasferite come oggetto dati con codifica byte64 nel campo `GroundTruth`. Se utilizzi un AWS SDK per chiamare`UpdateDatasetEntries`, l'SDK codifica i dati al posto tuo. Ogni riga JSON contiene informazioni per una singola immagine, come le etichette assegnate o le informazioni sui riquadri di delimitazione. Esempio:
```
{"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"}}
```
Per ulteriori informazioni, consulta [Creazione di un file manifesto](md-create-manifest-file.md).
Usa il campo `source-ref` come chiave per identificare le immagini da aggiornare. Se il set di dati non contiene un valore di campo `source-ref` corrispondente, la riga JSON viene aggiunta come nuova immagine.
**Per aggiungere altre immagini a un set di dati (SDK)**
1. Se non l'hai già fatto, installa e configura il e il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Usa i seguenti esempi per aggiungere righe JSON a un set di dati.
------
#### [ CLI ]
Sostituisci il valore di `GroundTruth` con le righe JSON che desideri utilizzare. È necessario evitare qualsiasi carattere speciale all'interno della riga JSON.
```
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 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ dataset\$1arn`` — l'ARN del set di dati da aggiornare.
+ updates\$1file`` — il file che contiene gli aggiornamenti di riga JSON.
```
# 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`` — l'ARN del set di dati da aggiornare.
+ update\$1file`` — il file che contiene gli aggiornamenti di riga JSON.
```
/*
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);
}
}
}
```
------
# Creazione di un set di dati utilizzando un set di dati esistente (SDK)
La procedura seguente mostra come creare un set di dati da un set di dati esistente utilizzando l'[CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)operazione.
1. Se non l'hai già fatto, installa e configura il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Utilizza il codice di esempio seguente per creare un set di dati copiando un altro set di dati.
------
#### [ AWS CLI ]
Usa il codice seguente per creare il set di dati. Sostituisci quanto segue:
+ `project_arn` — l'ARN del progetto a cui desideri aggiungere il set di dati.
+ `dataset_type` — con il tipo di set di dati (`TRAIN` o `TEST`) che desideri creare nel progetto.
+ `dataset_arn` — con l'ARN del set di dati che desidera copiare.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type dataset_type \
--dataset-source '{ "DatasetArn" : "dataset_arn" }' \
--profile custom-labels-access
```
------
#### [ Python ]
L'esempio seguente crea un set di dati utilizzando un set di dati esistente e mostra il suo ARN.
Per eseguire il programma, fornisci i seguenti argomenti riga di comando:
+ `project_arn` — l'ARN del progetto che desideri utilizzare.
+ `dataset_type` — il tipo di set di dati del progetto che desideri creare (`train` o `test`).
+ `dataset_arn` — l'ARN del set di dati dal quale desideri creare il set di dati.
```
# 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 ]
L'esempio seguente crea un set di dati utilizzando un set di dati esistente e mostra il suo ARN.
Per eseguire il programma, fornisci i seguenti argomenti riga di comando:
+ `project_arn` — l'ARN del progetto che desideri utilizzare.
+ `dataset_type` — il tipo di set di dati del progetto che desideri creare (`train` o `test`).
+ `dataset_arn` — l'ARN del set di dati dal quale desideri creare il set di dati.
```
/*
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);
}
}
}
```
------
# Descrizione di un set di dati (SDK)
È possibile utilizzare l'API `DescribeDataset` per ottenere informazioni su un set di dati.
**Per descrivere un set di dati (SDK)**
1. Se non l'hai già fatto, installa e configura il AWS CLI e il AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Usa il seguente codice di esempio per descrivere un set di dati.
------
#### [ AWS CLI ]
Modifica il valore di `dataset-arn` nell’ARN del set di dati che desideri descrivere.
```
aws rekognition describe-dataset --dataset-arn dataset_arn \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ dataset\$1arn — l'ARN del set di dati da descrivere.
```
# 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 — l'ARN del set di dati da descrivere.
```
/*
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);
}
}
}
```
------
# Elencare le voci del set di dati (SDK)
Puoi utilizzare l'API `ListDatasetEntries` per elencare le righe JSON per ogni immagine in un set di dati. Per ulteriori informazioni, consulta [Creazione di un file manifesto](md-create-manifest-file.md).
**Per elencare le voci del set di dati (SDK)**
1. Se non l'hai già fatto, installa e configura il AWS CLI e il AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Usa il seguente codice di esempio per elencare le voci in un set di dati
------
#### [ AWS CLI ]
Modifica il valore di `dataset-arn` nell’ARN del set di dati che desideri elencare.
```
aws rekognition list-dataset-entries --dataset-arn dataset_arn \
--profile custom-labels-access
```
Per elencare solo le righe JSON con errori, specificare `has-errors`.
```
aws rekognition list-dataset-entries --dataset-arn dataset_arn \
--has-errors \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ dataset\$1arn — l'ARN del set di dati da elencare.
+ show\$1errors\$1only — specifica `true` se desideri visualizzare solo gli errori, `false` in caso contrario.
```
# 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 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ dataset\$1arn — l'ARN del set di dati da elencare.
+ show\$1errors\$1only — specifica `true` se desideri visualizzare solo gli errori, `false` in caso contrario.
```
/*
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);
}
}
}
```
------
# Distribuzione di un set di dati di addestramento (SDK)
Amazon Rekognition Custom Labels richiede un set di dati di addestramento e un set di dati di test per addestrare il modello.
Se utilizzi l'API, puoi utilizzare l'[DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries)API per distribuire il 20% del set di dati di addestramento in un set di dati di test vuoto. La distribuzione del set di dati di addestramento può essere utile se è disponibile un solo file manifest. Utilizza il singolo file manifest per creare il set di dati di addestramento. Quindi crea un set di dati di test vuoto e utilizza `DistributeDatasetEntries` per popolare il set di dati di test.
**Nota**
Se utilizzi la console di Amazon Rekognition Custom Labels e inizi con un singolo progetto di set di dati, Amazon Rekognition Custom Labels divide (distribuisce) il set di dati di addestramento, durante l'addestramento, per creare un set di dati di test. Il 20% delle voci del set di dati di addestramento viene spostato nel set di dati di test.
**Per distribuire un set di dati di addestramento (SDK)**
1. Se non l'hai ancora fatto, installa e configura il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Crea un progetto. Per ulteriori informazioni, consulta [Creare un progetto Amazon Rekognition Custom Labels (SDK)](mp-create-project.md#mp-create-project-sdk).
1. Crea il tuo set di dati di addestramento. Per informazioni sui set di dati, consulta [Creazione di set di dati di addestramento e test](creating-datasets.md).
1. Crea di un set di dati di test vuoto.
1. Utilizza il seguente codice di esempio per distribuire il 20% delle voci del set di dati di addestramento nel set di dati di test. Puoi ottenere gli Amazon Resource Names (ARN) per i set di dati di un progetto chiamando. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjects) Per il codice di esempio, consulta [Descrizione di un progetto (SDK)](md-describing-project-sdk.md).
------
#### [ AWS CLI ]
Modifica il valore di `training_dataset-arn` e `test_dataset_arn` con gli ARN dei set di dati che desideri utilizzare.
```
aws rekognition distribute-dataset-entries --datasets ['{"Arn": "training_dataset_arn"}, {"Arn": "test_dataset_arn"}'] \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ training\$1dataset\$1arn — l'ARN del set di dati di addestramento da cui distribuisci le voci.
+ test\$1dataset\$1arn — l'ARN del set di dati di test a cui distribuisci le voci.
```
# 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 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ training\$1dataset\$1arn — l'ARN del set di dati di addestramento da cui distribuisci le voci.
+ test\$1dataset\$1arn — l'ARN del set di dati di test a cui distribuisci le voci.
```
/*
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);
}
}
}
```
------
# Eliminazione di un set di dati
È possibile eliminare i set di dati di addestramento e di test da un progetto.
**Topics**
+ [Eliminazione di un set di dati (console)](#md-delete-dataset-console)
+ [Eliminazione di un set di dati Amazon Rekognition Custom Labels (SDK)](#md-delete-dataset-sdk)
## Eliminazione di un set di dati (console)
Utilizza la procedura seguente per eliminare un set di dati. Successivamente, se il progetto ha un set di dati (di addestramento o di test) rimanente, viene visualizzata la pagina dei dettagli del progetto. Se il progetto non ha set di dati rimanenti, viene visualizzata la pagina **Crea set di dati**.
Se elimini il set di dati di addestramento, è necessario creare un nuovo set di dati di addestramento per il progetto prima di poter addestrare un modello. Per ulteriori informazioni, consulta [Creazione di set di dati di addestramento e test con immagini](md-create-dataset.md).
Se elimini il set di dati di test, è possibile addestrare un modello senza creare un nuovo set di dati di test. Durante l'addestramento, il set di dati di addestramento viene suddiviso per creare un nuovo set di dati di test per il progetto. La suddivisione del set di dati di addestramento riduce il numero di immagini disponibili per l’addestramento. Per mantenere la qualità, consigliamo di creare un nuovo set di dati di test prima di addestrare un modello. Per ulteriori informazioni, consulta [Aggiungere un set di dati a un progetto](md-add-dataset.md).
**Eliminare un set di dati**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Nel riquadro a sinistra, scegli **Usa etichette personalizzate**. Viene visualizzata la pagina iniziale di Amazon Rekognition Custom Labels.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**. Viene visualizzata la vista Progetti.
1. Scegli il progetto contenente il set di dati che desideri eliminare.
1. Nel pannello di navigazione a sinistra, sotto il nome del progetto, scegli **Set di dati**
1. Scegli **Azioni**
1. Per eliminare il set di dati di addestramento, scegli **Elimina set di dati di addestramento**.
1. Per eliminare il set di dati di test, scegli **Elimina set di dati di test**.
1. Nella finestra di dialogo **Elimina set di dati di *addestramento o di test***, immettete **elimina** per confermare che desideri eliminare il set di dati.
1. Scegli **Elimina set di dati di *addestramento o di test*** per eliminare il set di dati.
## Eliminazione di un set di dati Amazon Rekognition Custom Labels (SDK)
Puoi eliminare un set di dati Amazon Rekognition Custom Labels [DeleteDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteDataset)chiamando e fornendo l'Amazon Resource Name (ARN) del set di dati che desideri eliminare. Per ottenere i set ARNs di dati di formazione e test all'interno di un progetto, chiama. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjects) La risposta include una serie di [ProjectDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectDescription)oggetti. Il set di dati ARNs (`DatasetArn`) e i tipi di set di dati (`DatasetType`) sono nell'`Datasets`elenco.
Se elimini il set di dati di addestramento, è necessario creare un nuovo set di dati di addestramento per il progetto prima di poter addestrare un modello. Se elimini il set di dati di test, è necessario creare un nuovo set di dati di test prima di poter addestrare il modello. Per ulteriori informazioni, consulta [Aggiungere un set di dati a un progetto (SDK)](md-add-dataset.md#md-add-dataset-sdk).
**Per eliminare un set di dati (SDK)**
1. Se non l'hai già fatto, installa e configura il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Per eliminare un set di dati, utilizza il seguente codice.
------
#### [ AWS CLI ]
Modifica il valore di `dataset-arn` con l’ARN del set di dati che desideri eliminare.
```
aws rekognition delete-dataset --dataset-arn dataset-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ dataset\$1arn — l'ARN del set di dati da eliminare.
```
# 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 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ dataset\$1arn — l'ARN del set di dati da eliminare.
```
/*
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);
}
}
}
```
------