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à.
# Creazione di set di dati di addestramento e test con immagini
È possibile iniziare con un progetto che ha un singolo set di dati, o con un progetto che ha il set di dati di addestramento e test separati. Se si inizia con un singolo set di dati, Amazon Rekognition Custom Labels divide il set di dati durante l'addestramento per crearne uno di addestramento (80%) e uno di test (%20) per il tuo progetto. Iniziare con un singolo set di dati, se si desidera che Amazon Rekognition Custom Labels decida dove utilizzare le immagini per l’addestramento e i test. Per il controllo completo sull’addestramento, test e ottimizzazione delle prestazioni, si consiglia di iniziare il progetto con i set di dati di addestramento e test separati.
Si può creare il set di dati di addestramento e test per un progetto, importando immagini da una delle seguenti posizioni:
+ [Importazione di immagini da un bucket Amazon S3](md-create-dataset-s3.md)
+ [Importazione di immagini da un computer locale](md-create-dataset-computer.md)
+ [Utilizzo di un file manifesto per importare immagini](md-create-dataset-ground-truth.md)
+ [Copia del contenuto da un set di dati esistente](md-create-dataset-existing-dataset.md)
Se si inizia il progetto con il set di dati di addestramento e test separati, si possono utilizzare posizioni di origine diverse per ogni set di dati.
A seconda della provenienza da cui importi le immagini, queste potrebbero non essere etichettate. Ad esempio, le immagini importate da un computer locale non sono etichettate. Le immagini importate da un file manifest di Amazon SageMaker AI Ground Truth sono etichettate. Si può utilizzare la console Amazon Rekognition Custom Labels per aggiungere, modificare e assegnare etichette. Per ulteriori informazioni, consulta [Immagini etichettate](md-labeling-images.md).
Se le immagini vengono caricate con errori, mancano delle immagini o delle etichette nelle immagini, consultare [Eseguire il debug di un modello di addestramento fallito](tm-debugging.md).
Per ulteriori informazioni sui set di dati, consulta [Gestione di set di dati](managing-dataset.md).
## Creare set di dati di addestramento e test (SDK)
Puoi utilizzare l' AWS SDK per creare set di dati di addestramento e test.
L'`CreateDataset`operazione consente di specificare facoltativamente i tag durante la creazione di un nuovo set di dati, ai fini della categorizzazione e della gestione delle risorse.
### Addestrare un set di dati
È possibile utilizzare l' AWS SDK per creare un set di dati di addestramento nei seguenti modi.
+ Utilizzalo [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)con un file manifesto in formato Amazon Sagemaker fornito da te. Per ulteriori informazioni, consulta [Creazione di un file manifesto](md-create-manifest-file.md). Per il codice di esempio, 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).
+ Utilizzare `CreateDataset` per copiare un set di dati esistente di Amazon Rekognition Custom Labels. Per il codice di esempio, consulta [Creazione di un set di dati utilizzando un set di dati esistente (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Creare un set di dati vuoto con `CreateDataset` e aggiungere, in un secondo momento, le voci del set di dati con [UpdateDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UpdateDatasetEntries). Per creare un set di dati vuoto, consultare [Aggiungere un set di dati a un progetto](md-add-dataset.md). Per aggiungere immagini a un set di dati, consulta [Aggiungere altre immagini (SDK)](md-add-images.md#md-add-images-sdk). È necessario aggiungere le voci del set di dati prima di poter addestrare un modello.
### Descrive un set di dati
Puoi utilizzare l' AWS SDK per creare un set di dati di test nei seguenti modi:
+ Utilizzalo [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)con un file manifesto in formato Amazon Sagemaker fornito da te. Per ulteriori informazioni, consulta [Creazione di un file manifesto](md-create-manifest-file.md). Per il codice di esempio, 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).
+ Utilizzare `CreateDataset` per copiare un set di dati esistente di Amazon Rekognition Custom Labels. Per il codice di esempio, consulta [Creazione di un set di dati utilizzando un set di dati esistente (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Creare un set di dati vuoto con `CreateDataset` e aggiungere, in un secondo momento, le voci del set di dati con `UpdateDatasetEntries`. Per creare un set di dati vuoto, consultare [Aggiungere un set di dati a un progetto](md-add-dataset.md). Per aggiungere immagini a un set di dati, consulta [Aggiungere altre immagini (SDK)](md-add-images.md#md-add-images-sdk). È necessario aggiungere le voci del set di dati prima di poter addestrare un modello.
+ Suddividere il set di dati di addestramento in quello di addestramento e quello di test. Per prima cosa creare un set di dati di test vuoto con `CreateDataset`. Quindi sposta il 20% delle voci del set di dati di addestramento nel set di dati di test chiamando. [DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries) Per creare un set di dati vuoto, consultare [Aggiungere un set di dati a un progetto (SDK)](md-add-dataset.md#md-add-dataset-sdk). Per suddividere il set di dati di addestramento, vedere [Distribuzione di un set di dati di addestramento (SDK)](md-distributing-datasets.md).
# Importazione di immagini da un bucket Amazon S3
Le immagini vengono caricate da un bucket Amazon S3. Puoi utilizzare il bucket della console o un altro bucket Amazon S3 nel tuo account. AWS Se si usa il bucket della console, le autorizzazioni richieste sono già configurate. Se non si utilizza il bucket della console, consultare [Accesso a bucket Amazon S3 esterni](su-console-policy.md#su-external-buckets).
**Nota**
Non puoi utilizzare l' AWS SDK per creare un set di dati direttamente dalle immagini in un bucket Amazon S3. Creare, invece, un file manifest che faccia riferimento alle posizioni di origine delle immagini. Per ulteriori informazioni, consulta [Utilizzo di un file manifesto per importare immagini](md-create-dataset-ground-truth.md)
Durante la creazione del set di dati, si può scegliere di assegnare nomi alle etichette delle immagini in base al nome della cartella che contiene le immagini. La(e) cartella(e) deve essere una sottocartella del percorso della cartella Amazon S3 specificato nella **posizione della cartella S3** durante la creazione del set di dati. Per creare un set di dati, consultare [Creazione di un set di dati importando immagini da un bucket S3](#cd-procedure).
Ad esempio, si supponga che un bucket Amazon S3 abbia la struttura della cartella. Se si specifica la posizione della cartella Amazon S3 come *dispositivi S3-bucket/Alexa*, le immagini nella cartella *echo* vengono assegnate all'etichetta *echo*. Allo stesso modo, alle immagini nella cartella *echo-dot* viene assegnata l'etichetta *echo-dot*. I nomi delle sottocartelle più profonde non vengono utilizzati per etichettare le immagini. Viene invece utilizzata la sottocartella appropriata della posizione della cartella Amazon S3. *Ad esempio, alle immagini contenute nella cartella viene assegnata l'etichetta *white-echo-dots*echo-dot.* Le immagini a livello della posizione della cartella S3 (*dispositivi alexa*) non hanno etichette assegnate.
Le cartelle più profonde nella struttura delle cartelle possono essere utilizzate per etichettare le immagini, specificando una posizione più profonda della cartella S3. Ad esempio, se si specifica *S3- bucket/alexa-devices/echo -dot*, le immagini nella cartella vengono etichettate. *white-echo-dot*white-echo-dot** Le immagini che si trovano fuori dalla posizione della cartella s3 specificata, come *echo*, non vengono importate.
```
S3-bucket
└── alexa-devices
├── echo
│ ├── echo-image-1.png
│ └── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── white-echo-dot
│ ├── white-echo-dot-image-1.png
│ ├── white-echo-dot-image-2.png
│
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
Ti consigliamo di utilizzare il bucket Amazon S3 (bucket console) creato per te da Amazon Rekognition quando hai aperto la console per la prima volta nella regione corrente. AWS Se il bucket Amazon S3 che si sta utilizzando è diverso (esterno) da quello della console, la console richiede di configurare le autorizzazioni appropriate durante la creazione del set di dati. Per ulteriori informazioni, consulta [Passaggio 2: Configurare le autorizzazioni della console di Amazon Rekognition Custom Labels](su-console-policy.md).
## Creazione di un set di dati importando immagini da un bucket S3
La procedura seguente illustra come creare un set di dati utilizzando immagini archiviate nel bucket Console S3. Le immagini vengono etichettate automaticamente con il nome della cartella in cui sono archiviate.
Dopo aver importato le immagini, si possono aggiungere altre immagini, assegnare le etichette e aggiungere i riquadri di delimitazione dalla pagina della galleria di un set di dati. Per ulteriori informazioni, consulta [Immagini etichettate](md-labeling-images.md).
**Caricare i contenuti in un bucket Amazon Simple Storage Service**
1. Creare una cartella nel tuo sistema di file locale. Usare un nome cartella come *alexa-devices*.
1. All'interno della cartella appena creata, creare delle cartelle con il nome di ciascuna etichetta che si desidera utilizzare. Ad esempio, *echo* ed *echo-dot*. La struttura della cartella dovrebbe essere simile alla seguente.
```
alexa-devices
├── echo
│ ├── echo-image-1.png
│ ├── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
1. Inserire le immagini che corrispondono a un'etichetta nella cartella che ha lo stesso nome.
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. [Aggiungere la cartella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) creata nel passo 1 del bucket Amazon S3 (bucket console) realizzato da Amazon Rekognition Custom Labels durante *la prima configurazione.* Per ulteriori informazioni, consulta [Gestione di un progetto Amazon Rekognition Custom Labels](managing-project.md).
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Scegli **Usa etichette personalizzate**.
1. Scegli **Avvia**.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**.
1. Nella pagina **Progetti**, scegliere il progetto a cui aggiungere un set di dati. Viene visualizzata la pagina dei dettagli del progetto.
1. Scegli **Crea set di dati**. Viene visualizzata la pagina **Creare set di dati**.
1. In **Configurazione iniziale**, scegliere **Iniziare con un singolo set di dati** o **Iniziare con un set di dati di addestramento**. Per creare un modello di qualità superiore, consigliamo di iniziare con set di dati di addestramento e test separati.
------
#### [ Single dataset ]
1. Nella sezione **Training dataset details (Dettagli del dataset di addestramento)**, scegliere **Import images from S3 bucket (Importa immagini dal bucket S3)**.
1. Nella sezione **Training dataset details (Dettagli del set di dati di addestramento)**, inserire le informazioni dei passaggi da 13 a 15 nella sezione **Image source configuration (Configurazione dell'origine dell'immagine)**.
------
#### [ Separate training and test datasets ]
1. Nella sezione **Training dataset details (Dettagli del set di dati di addestramento)**, scegliere **Import images from S3 bucket (Importa immagini dal bucket S3)**.
1. Nella sezione **Training dataset details (Dettagli del set di dati di addestramento)**, inserire le informazioni dei passaggi da 13 a 15 nella sezione **Image source configuration (Configurazione dell'origine dell'immagine)**.
1. Nella sezione **Test dataset details (Dettagli del set di dati di test)**, scegliere **Import images from S3 bucket (Importa immagini dal bucket S3)**.
1. Nella sezione **Training dataset details (Dettagli del set di dati di addestramento)**, inserire le informazioni dei passaggi da 13 a 15 nella sezione **Image source configuration (Configurazione dell'origine dell'immagine)**.
------
1. Scegliere **Import images from Amazon S3 bucket (Importa immagini dal bucket Amazon S3)**.
1. Nell'**URI S3**, inserire la posizione del bucket Amazon S3 e il percorso della cartella.
1. Scegliere **Automatically attach labels to images based on the folder (Allegare automaticamente etichette alle immagini secondo la cartella)**.
1. Scegli **Crea database**. Si apre la pagina dei set di dati per il progetto.
1. Se si deve aggiungere o modificare etichette, fare [Immagini etichettate](md-labeling-images.md).
1. Seguire i passaggi indicati in [Addestramento di un modello (Console)](training-model.md#tm-console) per addestrare il modello.
# Importazione di immagini da un computer locale
Le immagini vengono caricate direttamente dal computer. Puoi caricare fino a 30 immagini alla volta.
Le immagini caricate non hanno etichette associate. Per ulteriori informazioni, consulta [Immagini etichettate](md-labeling-images.md). Se ci sono molte immagini da caricare, valutare l'utilizzo di un bucket Amazon S3. Per ulteriori informazioni, consulta [Importazione di immagini da un bucket Amazon S3](md-create-dataset-s3.md).
**Nota**
Non puoi utilizzare l' AWS SDK per creare un set di dati con immagini locali. Creare invece un file manifest e caricare le immagini in un bucket Amazon S3. Per ulteriori informazioni, consulta [Utilizzo di un file manifesto per importare immagini](md-create-dataset-ground-truth.md).
**Creare un set di dati utilizzando immagini in un computer locale (console)**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Scegli **Usa etichette personalizzate**.
1. Scegli **Avvia**.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**.
1. Nella pagina **Progetti**, scegliere il progetto a cui aggiungere un set di dati. Viene visualizzata la pagina dei dettagli del progetto.
1. Scegli **Crea set di dati**. Viene visualizzata la pagina **Creare set di dati**.
1. In **Configurazione iniziale**, scegliere **Iniziare con un singolo set di dati** o **Iniziare con un set di dati di addestramento**. Per creare un modello di qualità superiore, consigliamo di iniziare con set di dati di addestramento e test separati.
------
#### [ Single dataset ]
1. Nella **Training dataset details section (Sezione dettagli del set di dati di addestramento)**, scegliere **Upload images from your computer (Caricare immagini dal tuo computer)**.
1. Scegli **Crea set di dati**.
1. Nella pagina del set di dati del progetto, scegliere **Add images (Aggiungi immagini)**.
1. Scegliere le immagini che si desiderano caricare nel set di dati dai file del tuo computer. Puoi trascinare le immagini o scegliere le immagini che desideri caricare dal tuo computer locale.
1. Scegli **Carica immagini**.
------
#### [ Separate training and test datasets ]
1. Nella sezione **Dettagli del set di dati di allenamento**, scegliere **Carica immagini dal tuo computer**.
1. Nella sezione **Dettagli del set di dati di test**, scegli **Carica immagini dal tuo computer**.
**Nota**
I set di dati di addestramento e test possono avere diverse fonti di immagini.
1. Scegli **Crea database**. La pagina dei set di dati del progetto appare con una scheda di **Addestramento** e una scheda di **Test** per i rispettivi set di dati.
1. Scegli **Azioni**, quindi scegli **Aggiungi immagini al set di dati di addestramento**.
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.
1. Scegli **Carica immagini**.
1. Ripetere le fasi 5e - 5g. Per il passaggio 5e, scegliere **Actions (Azioni)**, quindi scegliere **Add images to test dataset (Aggiungere immagini al set di dati di test)**.
------
1. Seguire i passaggi indicati in [Immagini etichettate](md-labeling-images.md) per etichettare le tue immagini.
1. Seguire i passaggi indicati in [Addestramento di un modello (Console)](training-model.md#tm-console) per addestrare il modello.
# Utilizzo di un file manifesto per importare immagini
Puoi creare un set di dati utilizzando un file manifest in formato Amazon SageMaker AI Ground Truth. Puoi utilizzare il file manifest da un job Amazon SageMaker AI Ground Truth. Se le immagini e le etichette non sono nel formato di un file manifest SageMaker AI Ground Truth, puoi creare un file manifest in formato SageMaker AI e utilizzarlo per importare le immagini etichettate.
L'`CreateDataset`operazione viene aggiornata per consentire di specificare facoltativamente i tag durante la creazione di un nuovo set di dati. I tag sono coppie chiave-valore che è possibile utilizzare per classificare e gestire le risorse.
**Topics**
+ [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)](#md-create-dataset-ground-truth-console)
+ [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (SDK)](#md-create-dataset-ground-truth-sdk)
+ [Crea una richiesta di set di dati](#create-dataset-ground-truth-request)
+ [Etichettatura delle immagini con un job Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md)
+ [Creazione di un file manifesto](md-create-manifest-file.md)
+ [Importazione di etichette a livello di immagine nei file manifest](md-create-manifest-file-classification.md)
+ [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md)
+ [Regole di convalida per i file manifest](md-create-manifest-file-validation-rules.md)
+ [Conversione di altri formati set di dati in un file manifest](md-converting-to-sm-format.md)
## Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)
La procedura seguente mostra come creare un set di dati utilizzando un file manifest in formato SageMaker AI Ground Truth.
1. Creare un file manifest per il set di dati di addestramento in uno dei seguenti modi:
+ Crea un file manifest con un SageMaker AI GroundTruth Job seguendo le istruzioni all'indirizzo[Etichettatura delle immagini con un job Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Creare il file manifest seguendo le istruzioni riportate all'indirizzo [Creazione di un file manifesto](md-create-manifest-file.md).
Se si desidera creare un set di dati di test, ripetere il passaggio 1 per creare il set di dati di test.
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Scegli **Usa etichette personalizzate**.
1. Scegli **Avvia**.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**.
1. Nella pagina **Progetti**, scegliere il progetto a cui aggiungere un set di dati. Viene visualizzata la pagina dei dettagli del progetto.
1. Scegli **Crea set di dati**. Viene visualizzata la pagina **Creare set di dati**.
1. In **Configurazione iniziale**, scegliere **Iniziare con un singolo set di dati** o **Iniziare con un set di dati di addestramento**. Per creare un modello di qualità superiore, consigliamo di iniziare con set di dati di addestramento e test separati.
------
#### [ Single dataset ]
1. Nella sezione **Dettagli del set di dati di addestramento**, scegli **Importa immagini etichettate da SageMaker Ground Truth**.
1. In**.manifest file location**, inserire la posizione del file manifest che è stata creata al passaggio 1.
1. Scegli **Crea set di dati**. Si apre la pagina dei set di dati per il progetto.
------
#### [ Separate training and test datasets ]
1. Nella sezione **Dettagli del set di dati di addestramento**, scegli **Importa immagini etichettate da SageMaker Ground Truth**.
1. In**.manifest file location**, inserire la posizione del file manifest del set di dati di addestramento che è stata creata al passaggio 1.
1. Nella sezione **Dettagli del set di dati di test**, scegli **Importa immagini etichettate da SageMaker Ground Truth**.
**Nota**
I set di dati di addestramento e test possono avere diverse fonti di immagini.
1. In**.manifest file location**, inserire la posizione del file manifest del set di dati di test che è stata creata al passaggio 1.
1. Scegli **Crea database**. Si apre la pagina dei set di dati per il progetto.
------
1. Se si deve aggiungere o modificare etichette, fare [Immagini etichettate](md-labeling-images.md).
1. Seguire i passaggi indicati in [Addestramento di un modello (Console)](training-model.md#tm-console) per addestrare il modello.
## Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (SDK)
La procedura seguente mostra come creare set di dati di addestramento o test da un file manifest utilizzando l'API. [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)
Puoi utilizzare un file manifest esistente, come l'output di un [job SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md), o creare il tuo [file manifest](md-create-manifest-file.md).
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. Creare un file manifest per il set di dati di addestramento in uno dei seguenti modi:
+ Crea un file manifest con un SageMaker AI GroundTruth Job seguendo le istruzioni all'indirizzo[Etichettatura delle immagini con un job Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Creare il file manifest seguendo le istruzioni riportate all'indirizzo [Creazione di un file manifesto](md-create-manifest-file.md).
Se si desidera creare un set di dati di test, ripetere il passaggio 2 per creare il set di dati di test.
1. Utilizzare il seguente codice di esempio per creare il set di dati di addestramento e test.
------
#### [ AWS CLI ]
Usa il seguente codice per creare un set di dati. Sostituisci quanto segue:
+ `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)
+ `bucket`: il bucket che contiene il file manifest per il set di dati.
+ `manifest_file`: il nome e il percorso del file manifest.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type type \
--dataset-source '{ "GroundTruthManifest": { "S3Object": { "Bucket": "bucket", "Name": "manifest_file" } } }' \
--profile custom-labels-access
--tags '{"key1": "value1", "key2": "value2"}'
```
------
#### [ Python ]
Usare i seguenti valori per creare un set di dati. Fornisci i seguenti parametri di riga di comando:
+ `project_arn`: l'ARN del progetto a cui si desidera aggiungere il set di dati di test.
+ `dataset_type`: il tipo di set di dati che si desidera creare (`train` o `test`).
+ `bucket`: il bucket che contiene il file manifest per il set di dati.
+ `manifest_file`: il nome e il percorso del file manifest.
```
#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(rek_client, project_arn, dataset_type, bucket, manifest_file):
"""
Creates an 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).
:param bucket: The S3 bucket that contains the manifest file.
:param manifest_file: The path and filename of the manifest file.
"""
try:
#Create the project
logger.info("Creating %s dataset for project %s",dataset_type, project_arn)
dataset_type = dataset_type.upper()
dataset_source = json.loads(
'{ "GroundTruthManifest": { "S3Object": { "Bucket": "'
+ bucket
+ '", "Name": "'
+ manifest_file
+ '" } } }'
)
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
)
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 dataset."
)
parser.add_argument(
"dataset_type", help="The type of the dataset that you want to create (train or test)."
)
parser.add_argument(
"bucket", help="The S3 bucket that contains the manifest file."
)
parser.add_argument(
"manifest_file", help="The path and filename of the manifest file."
)
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(rekognition_client,
args.project_arn,
args.dataset_type,
args.bucket,
args.manifest_file)
print(f"Finished creating dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usare i seguenti valori per creare un set di dati. Fornisci i seguenti parametri di riga di comando:
+ `project_arn`: l'ARN del progetto a cui si desidera aggiungere il set di dati di test.
+ `dataset_type`: il tipo di set di dati che si desidera creare (`train` o `test`).
+ `bucket`: il bucket che contiene il file manifest per il set di dati.
+ `manifest_file`: il nome e il percorso del file manifest.
```
/*
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.GroundTruthManifest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.S3Object;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateDatasetManifestFiles {
public static final Logger logger = Logger.getLogger(CreateDatasetManifestFiles.class.getName());
public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
String bucket, String name) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating {0} dataset for project : {1} from s3://{2}/{3} ",
new Object[] { datasetType, projectArn, bucket, name });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Could not create dataset. Unrecognized dataset type: {0}", datasetType);
throw new Exception("Could not create dataset. Unrecognized dataset type: " + datasetType);
}
GroundTruthManifest groundTruthManifest = GroundTruthManifest.builder()
.s3Object(S3Object.builder().bucket(bucket).name(name).build()).build();
DatasetSource datasetSource = DatasetSource.builder().groundTruthManifest(groundTruthManifest).build();
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).datasetSource(datasetSource).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
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 bucket = null;
String name = null;
String projectArn = null;
String datasetArn = 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"
+ " bucket - the S3 bucket that contains the manifest file.\n\n"
+ " name - the location and name of the manifest file within the bucket.\n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
bucket = args[2];
name = args[3];
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, bucket, name);
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. Se è necessario aggiungere o modificare etichette, confrontare [Gestione etichette (SDK)](md-labels.md#md-labels-sdk).
1. Seguire i passaggi indicati in [Addestramento di un modello (SDK)](training-model.md#tm-sdk) per addestrare il modello.
## Crea una richiesta di set di dati
Di seguito è riportato il formato della richiesta di operazione: CreateDataset
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```
# Etichettatura delle immagini con un job Amazon SageMaker AI Ground Truth
Con Amazon SageMaker AI Ground Truth, puoi utilizzare i lavoratori di Amazon Mechanical Turk, una società fornitrice a tua scelta, o una forza lavoro interna privata insieme all'apprendimento automatico che ti consente di creare un set di immagini etichettato. Amazon Rekognition Custom Labels importa i file manifest SageMaker AI Ground Truth da un bucket Amazon S3 da te specificato.
Amazon Rekognition Custom Labels supporta le seguenti attività SageMaker AI Ground Truth.
+ [Classificazione delle immagini ](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification.html)
+ [Riquadro di delimitazione](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-bounding-box.html)
I file importati sono le immagini e un file manifest. Il file manifest contiene informazioni sull'etichetta e sul riquadro di delimitazione per le immagini importate.
Amazon Rekognition necessita delle autorizzazioni per accedere al bucket Amazon S3 in cui sono archiviate le immagini. Se si usa il bucket per console configurato per te da Amazon Rekognition Custom Labels, le autorizzazioni richieste sono già configurate. Se non si utilizza il bucket della console, consultare [Accesso a bucket Amazon S3 esterni](su-console-policy.md#su-external-buckets).
## Creazione di un file manifest con un job SageMaker AI Ground Truth (Console)
La procedura seguente mostra come creare un set di dati utilizzando immagini etichettate da un job SageMaker AI Ground Truth. I file di output del lavoro vengono archiviati nel bucket della console Amazon Rekognition Custom Labels.
**Per creare un set di dati utilizzando immagini etichettate da un job SageMaker AI Ground Truth (console)**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel bucket della console, [creare una cartella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) per contenere le immagini di addestramento.
**Nota**
Il bucket della console viene creato quando apri per la prima volta la console Amazon Rekognition Custom Labels in una regione. AWS Per ulteriori informazioni, consulta [Gestione di un progetto Amazon Rekognition Custom Labels](managing-project.md).
1. [Carica le tue immagini](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella cartella che si è appena creato.
1. Nel bucket della console, creare una cartella per contenere l'output del lavoro Ground Truth.
1. Apri la console AI all'indirizzo. SageMaker [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)
1. Creare un lavoro di etichettatura Ground Truth. Avrai bisogno di Amazon S3 URLs per le cartelle che hai creato nei passaggi 2 e 4. Per ulteriori informazioni, consulta [Use Amazon SageMaker Ground Truth for Data Labeling](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html).
1. Annotare la posizione del file `output.manifest` nella cartella creata nel passaggio 4. Dovrebbe trovarsi nella sottocartella `Ground-Truth-Job-Name/manifests/output`.
1. Seguire le istruzioni riportate in [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) per creare un set di dati con il file manifest caricato. Per il passaggio 8, in **.manifest file location**, inserire l'URL di Amazon S3 per la posizione annotata nel passaggio precedente. Se utilizzi l' AWS SDK, fallo. [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)
1. Ripeti i passaggi da 1 a 6 per creare il job SageMaker AI Ground Truth per il tuo set di dati di test.
# Creazione di un file manifesto
Puoi creare un set di dati di test o addestramento importando un file manifest in formato SageMaker AI Ground Truth. Se le tue immagini sono etichettate in un formato diverso da un file manifest SageMaker AI Ground Truth, utilizza le seguenti informazioni per creare un file manifest in formato SageMaker AI Ground Truth.
I file manifest sono in formato [righe JSON](http://jsonlines.org), dove ogni riga è un oggetto JSON completo che rappresenta le informazioni di etichettatura di un'immagine. Amazon Rekognition Custom Labels supporta i manifesti SageMaker AI Ground Truth con righe JSON nei seguenti formati:
+ [Classification Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class): consente di aggiungere etichette a livello di immagine a un'immagine. Un'etichetta a livello di immagine definisce la classe di scena, concetto o oggetto (se non sono necessarie informazioni sulla posizione dell'oggetto) presenti in un'immagine. Un'immagine può avere più di un'etichetta a livello di immagine. Per ulteriori informazioni, consulta [Importazione di etichette a livello di immagine nei file manifest](md-create-manifest-file-classification.md).
+ [Bounding Box Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box): consente di etichettare la classe e la posizione di uno o più oggetti in un'immagine. Per ulteriori informazioni, consulta [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md).
Le righe JSON a livello di immagine e di posizione (riquadro di delimitazione) possono essere concatenate nello stesso file manifest.
**Nota**
Gli esempi di righe JSON in questa sezione sono formattati per garantire la leggibilità.
Quando importi un file manifest, Amazon Rekognition Custom Labels applica regole di convalida per limiti, sintassi e semantica. Per ulteriori informazioni, consulta [Regole di convalida per i file manifest](md-create-manifest-file-validation-rules.md).
Le immagini a cui fa riferimento un file manifest devono essere situate nello stesso bucket Amazon S3. Il file manifest può essere situato in un bucket Amazon S3 diverso da quello in cui sono archiviate le immagini. È necessario specificare la posizione di un'immagine nel campo `source-ref` di una riga JSON.
Amazon Rekognition necessita delle autorizzazioni per accedere al bucket Amazon S3 in cui sono archiviate le immagini. Se si usa il bucket per console configurato per te da Amazon Rekognition Custom Labels, le autorizzazioni richieste sono già configurate. Se non si utilizza il bucket della console, consultare [Accesso a bucket Amazon S3 esterni](su-console-policy.md#su-external-buckets).
**Topics**
+ [Creazione di un file manifest](#md-create-manifest-file-console)
## Creazione di un file manifest
La procedura seguente crea un progetto con un set di dati di addestramento e test. I set di dati vengono creati dai file manifest di addestramento e test originati dall'utente.
**Per creare un set di dati utilizzando un file manifest in formato SageMaker AI Ground Truth (console)**
1. Nel bucket della console, [crea una cartella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) per contenere i file manifest.
1. Nel bucket della console, crea una cartella per contenere le immagini.
1. Caricare le immagini nella cartella che è appena stata creata.
1. Crea un file manifest in formato SageMaker AI Ground Truth per il tuo set di dati di allenamento. Per ulteriori informazioni, consultare [Importazione di etichette a livello di immagine nei file manifest](md-create-manifest-file-classification.md) e [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md).
**Importante**
Il valore del campo `source-ref` in ogni riga JSON deve corrispondere a un'immagine che è stata caricata.
1. Crea un file manifest in formato SageMaker AI Ground Truth per il tuo set di dati di test.
1. [Caricare i file manifest](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella cartella che è appena stata creata.
1. Annotare la posizione del file manifest.
1. Seguire le istruzioni riportate in [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) per creare un set di dati con il file manifest caricato. Per il passaggio 8, in **.manifest file location**, inserire l'URL di Amazon S3 per la posizione annotata nel passaggio precedente. Se stai usando l' AWS SDK, fallo. [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)
# Importazione di etichette a livello di immagine nei file manifest
Per importare etichette a livello di immagine (immagini etichettate con scene, concetti o oggetti che non richiedono informazioni di localizzazione), aggiungi righe JSON in formato JSON in formato AI Ground SageMaker Truth Classification [Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class) a un file manifest. Un file manifest è composto da una o più righe JSON, una per ogni immagine che si desidera importare.
**Suggerimento**
Per semplificare la creazione di un file manifest, forniamo uno script Python che crea un file manifest da uno CSV. Per ulteriori informazioni, consulta [Creare un file manifest da CSV](ex-csv-manifest.md).
**Creare un file manifest per etichette a livello di immagine**
1. Creare un file di testo vuoto.
1. Aggiungere una riga JSON per ogni immagine che si vuole importare. Ogni riga JSON dovrebbe essere simile a quanto segue.
```
{"source-ref":"s3://custom-labels-console-us-east-1-nnnnnnnnnn/gt-job/manifest/IMG_1133.png","TestCLConsoleBucket":0,"TestCLConsoleBucket-metadata":{"confidence":0.95,"job-name":"labeling-job/testclconsolebucket","class-name":"Echo Dot","human-annotated":"yes","creation-date":"2020-04-15T20:17:23.433061","type":"groundtruth/image-classification"}}
```
1. Salvare il file. È possibile utilizzare l'estensione`.manifest`, ma non è necessaria.
1. Creare un set di dati utilizzando il file manifest che si è creato. Per ulteriori informazioni, consulta [Per creare un set di dati utilizzando un file manifest in formato SageMaker AI Ground Truth (console)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## Righe JSON a livello di immagine
In questa sezione viene mostrato come creare una riga JSON per una singola immagine. Considerare l'immagine seguente: Una scena per l'immagine seguente potrebbe chiamarsi *Sunrise (Alba)*.
![\[Tramonto su un lago con molo e piccole imbarcazioni, circondato da montagne.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/sunrise.png)
La riga JSON per l'immagine precedente, con la scena *Sunrise (Alba)*, potrebbe essere la seguente.
```
{
"source-ref": "s3://bucket/images/sunrise.png",
"testdataset-classification_Sunrise": 1,
"testdataset-classification_Sunrise-metadata": {
"confidence": 1,
"job-name": "labeling-job/testdataset-classification_Sunrise",
"class-name": "Sunrise",
"human-annotated": "yes",
"creation-date": "2020-03-06T17:46:39.176",
"type": "groundtruth/image-classification"
}
}
```
Osservare le seguenti informazioni.
### source-ref
(Obbligatorio) La posizione dell’immagine di Amazon S3. Il formato è `"s3://BUCKET/OBJECT_PATH"`. Le immagini in un set di dati importato devono essere archiviate nello stesso bucket Amazon S3.
### *testdataset-classification\$1Sunrise*
(Obbligatorio) L’etichetta dell'attributo. Scegliere il nome del campo. Il valore del campo (1 nell'esempio precedente) è un identificatore di attributo di etichetta. Non viene utilizzato da Amazon Rekognition Custom Labels e può essere qualsiasi valore intero. Devono esserci metadati corrispondenti identificati dal nome del campo con l'aggiunta di *-metadata*. Ad esempio, `"testdataset-classification_Sunrise-metadata"`.
### *testdataset-classification\$1Sunrise*-metadati
(Obbligatorio) Metadati sull'attributo etichetta. Il nome del campo deve essere lo stesso dell'attributo etichetta con l'aggiunta di *-metadata*.
*affidabilità*
(Obbligatorio) Attualmente non è utilizzato da Amazon Rekognition Custom Labels, ma deve essere fornito un valore compreso tra 0 e 1.
*job-name*
(Facoltativo) Un nome che si scegle per il lavoro che elabora l'immagine.
*class-name (nome classe)*
(Obbligatorio) Un nome classe scelto per la scena o il concetto che si applica all'immagine. Ad esempio, `"Sunrise"`.
*annotato dall'uomo*
(Obbligatorio) Specificare "yes" se l'annotazione è stata completata da un essere umano. In caso contrario, `"no"`.
*creation-date*
(Obbligatorio) La data e l'ora UTC (Coordinated Universal Time) in cui è stata creata l'etichetta.
*tipo*
(Obbligatorio) Il tipo di processo da applicare all'immagine. Per le etichette a livello di immagine, il valore è `"groundtruth/image-classification"`.
### Aggiungere più etichette a livello di immagine a un'immagine
È possibile aggiungere più etichette a un’immagine. Ad esempio, il JSON seguente aggiunge due etichette, *football (calcio)* e *ball (palla)*, a una singola immagine.
```
{
"source-ref": "S3 bucket location",
"sport0":0, # FIRST label
"sport0-metadata": {
"class-name": "football",
"confidence": 0.8,
"type":"groundtruth/image-classification",
"job-name": "identify-sport",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256"
},
"sport1":1, # SECOND label
"sport1-metadata": {
"class-name": "ball",
"confidence": 0.8,
"type":"groundtruth/image-classification",
"job-name": "identify-sport",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256"
}
} # end of annotations for 1 image
```
# Localizzazione di oggetti nei file manifest
È possibile importare immagini etichettate con informazioni sulla localizzazione degli oggetti aggiungendo righe JSON in formato SageMaker AI Ground Truth [Bounding Box Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) a un file manifest.
Le informazioni di localizzazione rappresentano la posizione di un oggetto in un'immagine. La posizione è rappresentata da un riquadro di delimitazione che circonda l'oggetto. La struttura del riquadro di delimitazione contiene le coordinate in alto a sinistra e la larghezza e l'altezza del riquadro di delimitazione. Una riga JSON in formato riquadro di delimitazione include riquadri di delimitazione per le posizioni di uno o più oggetti e la classe di ciascun di essi in un'immagine.
Un file manifest è composto da una o più righe JSON, ogni riga contiene le informazioni per una singola immagine.
**Creare un file manifest per la localizzazione degli oggetti**
1. Creare un file di testo vuoto.
1. Aggiungere una riga JSON per ogni immagine che si vuole importare. Ogni riga JSON dovrebbe essere simile a quanto segue.
```
{"source-ref": "s3://bucket/images/IMG_1186.png", "bounding-box": {"image_size": [{"width": 640, "height": 480, "depth": 3}], "annotations": [{ "class_id": 1, "top": 251, "left": 399, "width": 155, "height": 101}, {"class_id": 0, "top": 65, "left": 86, "width": 220, "height": 334}]}, "bounding-box-metadata": {"objects": [{ "confidence": 1}, {"confidence": 1}], "class-map": {"0": "Echo", "1": "Echo Dot"}, "type": "groundtruth/object-detection", "human-annotated": "yes", "creation-date": "2013-11-18T02:53:27", "job-name": "my job"}}
```
1. Salvare il file. È possibile utilizzare l'estensione`.manifest`, ma non è necessaria.
1. Creare un set di dati, usando il file che è appena stato creato. Per ulteriori informazioni, consulta [Per creare un set di dati utilizzando un file manifest in formato SageMaker AI Ground Truth (console)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## Oggetto riquadro di delimitazione righe JSON
In questa sezione viene mostrato come creare una riga JSON per una singola immagine. L'immagine seguente mostra i riquadri di delimitazione attorno ai dispositivi Amazon Echo e Amazon Echo Dot.
![\[Due altoparlanti intelligenti Amazon, uno con riquadro di delimitazione verde e uno blu, su una superficie di legno.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/echos.png)
Di seguito è riportata la riga JSON del riquadro di delimitazione per l'immagine precedente.
```
{
"source-ref": "s3://custom-labels-bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [{
"class_id": 1,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}, {
"class_id": 0,
"top": 65,
"left": 86,
"width": 220,
"height": 334
}]
},
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
"class-map": {
"0": "Echo",
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2013-11-18T02:53:27",
"job-name": "my job"
}
}
```
Osservare le seguenti informazioni.
### source-ref
(Obbligatorio) La posizione dell’immagine di Amazon S3. Il formato è `"s3://BUCKET/OBJECT_PATH"`. Le immagini in un set di dati importato devono essere archiviate nello stesso bucket Amazon S3.
### *bounding-box*
(Obbligatorio) L’etichetta dell'attributo. Scegliere il nome del campo. Contiene le dimensioni dell'immagine e i riquadri di delimitazione per ogni oggetto rilevato nell'immagine. Devono esserci metadati corrispondenti identificati dal nome del campo con l'aggiunta di *-metadata*. Ad esempio, `"bounding-box-metadata"`.
*image\$1size*
(Obbligatorio) Un array di elemento singolo contenente la dimensione dell'immagine in pixel.
+ *altezza*: (obbligatorio) l'altezza dell'immagine in pixel.
+ *larghezza*: (obbligatorio) lo spessore dell'immagine in pixel.
+ *profondità*: (obbligatorio) il numero di canali nell'immagine. Per l’immagine RGB, il valore è 3. Attualmente non è utilizzato da Amazon Rekognition Custom Labels, ma è richiesto un valore.
*annotations*
(Obbligatorio) Un array di informazioni sul riquadro di delimitazione per ogni oggetto rilevato nell'immagine.
+ *class\$1id*: (obbligatorio) Mappare con un'etichetta in *class-map*. Nell'esempio precedente, l'oggetto nell'immagine con *class\$1id* di `1` è l'Echo Dot.
+ *top*: (obbligatorio) la distanza tra la parte superiore dell'immagine e quella del riquadro di delimitazione, in pixel.
+ *left*: (obbligatorio) la distanza tra la parte sinistra dell'immagine e quella del riquadro di delimitazione, in pixel.
+ *larghezza*: (obbligatorio) la larghezza del riquadro di delimitazione, in pixel.
+ *altezza*: (obbligatorio) l'altezza del riquadro di delimitazione, in pixel.
### *bounding-box*-metadati
(Obbligatorio) Metadati sull'attributo etichetta. Il nome del campo deve essere lo stesso dell'attributo etichetta con l'aggiunta di *-metadata*. Un array di informazioni sui riquadri di delimitazione per ogni oggetto rilevato nell'immagine.
*Oggetti*
(Obbligatorio) Un array di oggetti che si trovano nell’immagine. Mappare l'array *delle annotazioni* per indice. L'attributo confidence non viene utilizzato da Amazon Rekognition Custom Labels.
*class-map*
(Obbligatorio) Una mappa delle classi che si applicano agli oggetti rilevati nell'immagine.
*tipo*
(Obbligatorio) Il tipo di lavoro di classificazione. `"groundtruth/object-detection"` identifica il lavoro come rilevamento di oggetti.
*creation-date*
(Obbligatorio) La data e l'ora UTC (Coordinated Universal Time) in cui è stata creata l'etichetta.
*annotato dall'uomo*
(Obbligatorio) Specificare "yes" se l'annotazione è stata completata da un essere umano. In caso contrario, `"no"`.
*job-name*
(Obbligatorio) Il nome del lavoro che elabora l’immagine.
# Regole di convalida per i file manifest
Quando importi un file manifest, Amazon Rekognition Custom Labels applica regole di convalida per limiti, sintassi e semantica. Lo schema SageMaker AI Ground Truth impone la convalida della sintassi. Per ulteriori informazioni, consulta [Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html). Di seguito sono riportate le regole di convalida per i limiti e la semantica.
**Nota**
Le regole di invalidità del 20% si applicano cumulativamente a tutte le regole di convalida. Se l'importazione supera il limite del 20% a causa di qualsiasi combinazione, come ad esempio il 15% di JSON non valide e il 15% di immagini non valide, l'importazione ha esito negativo.
Ogni oggetto del set di dati è una riga nel manifest. Anche le righe vuote o non valide vengono conteggiate come oggetti del set di dati.
Le sovrapposizioni sono (etichette comuni tra test e addestramento)/(etichette addestramento).
**Topics**
+ [Limits](#md-validation-rules-limits)
+ [Semantica](#md-validation-rules-semantics)
## Limits
| Convalida | Limite | Errore generato |
| --- | --- | --- |
| Dimensione del file manifest | Massimo 1 GB | Errore |
| Numero massimo di righe per un file manifest | Massimo 250.000 oggetti del set di dati come righe in un manifest. | Errore |
| Limite inferiore del numero totale di oggetti di set di dati validi per etichetta | >=1 | Errore |
| Limite inferiore sulle etichette | >=2 | Errore |
| Limite superiore sulle etichette | <= 250 | Errore |
| Numero minimo di riquadri di delimitazione per immagine | 0 | Nessuno |
| Numero massimo di riquadri di delimitazione per immagine | 50 | Nessuno |
## Semantica
| Convalida | Limite | Errore generato |
| --- | --- | --- |
| Manifest vuoto | | Errore |
| Oggetto source-ref mancante/non accessibile | Numero di oggetti inferiore al 20% | Attenzione |
| Oggetto source-ref mancante/non accessibile | Numero di oggetti > 20% | Errore |
| Etichette di test non presenti nel set di dati di addestramento | Almeno il 50% si sovrappone nelle etichette | Errore |
| Combinazione di esempi di etichette vs oggetti per la stessa etichetta in un set di dati. Classificazione e rilevamento per la stessa classe in un oggetto del set di dati. | | Nessun errore o avviso |
| Sovrapposizione di attività tra test e addestramento | Non dovrebbe esserci una sovrapposizione tra i set di dati di test e quelli di addestramento. | |
| Le immagini in un set di dati devono provenire dallo stesso bucket | Errore se gli oggetti si trovano in un bucket diverso | Errore |
# Conversione di altri formati set di dati in un file manifest
Puoi utilizzare le seguenti informazioni per creare file manifest in formato Amazon SageMaker AI da una varietà di formati di set di dati di origine. Dopo aver creato il file manifest, utilizzarlo per creare un set di dati. Per ulteriori informazioni, consulta [Utilizzo di un file manifesto per importare immagini](md-create-dataset-ground-truth.md).
**Topics**
+ [Trasformazione di un set di dati COCO in un formato di file manifesto](md-transform-coco.md)
+ [Trasformazione dei file manifest multietichetta di SageMaker AI Ground Truth](md-gt-cl-transform.md)
+ [Creare un file manifest da CSV](ex-csv-manifest.md)
# Trasformazione di un set di dati COCO in un formato di file manifesto
[COCO](http://cocodataset.org/#home) è un formato per specificare set di dati di rilevamento, segmentazione e didascalia di oggetti su larga scala. Questo [esempio](md-coco-transform-example.md) Python mostra come trasformare un set di dati in formato di rilevamento di oggetti COCO in un [file manifest in formato riquadro di delimitazione](md-create-manifest-file-object-detection.md) di Amazon Rekognition Custom Labels. Questa sezione contiene anche informazioni che si possono utilizzare per scrivere il proprio codice.
Un file JSON in formato COCO è composto da cinque sezioni che forniscono informazioni per *un intero set di dati*. Per ulteriori informazioni, consulta [Il formato del set di dati COCO](md-coco-overview.md).
+ `info`: informazioni generali sul set di dati.
+ `licenses `: informazioni sulla licenza per le immagini nel set di dati.
+ [`images`](md-coco-overview.md#md-coco-images): un elenco di immagini nel set di dati.
+ [`annotations`](md-coco-overview.md#md-coco-annotations): un elenco di annotazioni (compresi i riquadri di delimitazione) presenti in tutte le immagini del set di dati.
+ [`categories`](md-coco-overview.md#md-coco-categories): un elenco di categorie di etichette.
Sono necessarie le informazioni delle liste `images`, `annotations` e `categories` per creare un file manifest di Amazon Rekognition Custom Labels.
Un file manifest di Amazon Rekognition Custom Labels è in formato righe JSON, in cui ogni riga contiene il riquadro di delimitazione e le informazioni sull'etichetta per uno o più oggetti *in un'immagine.* Per ulteriori informazioni, consulta [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md).
## Mappatura degli oggetti COCO su una riga JSON di Custom Labels
Per trasformare un set di dati in formato COCO, mappare il set di dati COCO a un file manifest di Amazon Rekognition Custom Labels per posizionare gli oggetti. Per ulteriori informazioni, consulta [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md). Per creare una riga JSON per ogni immagine, il file manifest deve mappare il set di dati COCO e il campo dell'oggetto`image`. `annotation` `category` IDs
Di seguito è riportato un esempio del file manifest CSV. Per ulteriori informazioni, consulta [Il formato del set di dati COCO](md-coco-overview.md).
```
{
"info": {
"description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
},
"licenses": [
{"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
],
"images": [
{"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
{"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
],
"annotations": [
{"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
{"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
{"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
],
"categories": [
{"supercategory": "speaker","id": 0,"name": "echo"},
{"supercategory": "speaker","id": 1,"name": "echo dot"}
]
}
```
Il seguente diagramma mostra come le liste set di dati COCO per un *set di dati* mappino le righe JSON di Amazon Rekognition Custom Labels di un’*immagine*. Ogni riga JSON per un'immagine possiede un campo di metadati source-ref, job e job. I colori corrispondenti indicano le informazioni per una singola immagine. Nota che nel manifesto una singola immagine può avere più annotazioni e metadati/categorie.
![\[Diagramma che mostra la struttura di Coco Manifest, con immagini, annotazioni e categorie contenute al suo interno.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/coco-transform.png)
**Ottenere gli oggetti COCO per una singola riga JSON**
1. Per ogni immagine dell'elenco delle immagini, recuperarne l'annotazione dalla lista in cui il valore del campo di annotazione corrisponde al campo `image_id` dell'immagine `id`.
1. Per ogni annotazione corrispondente al passaggio 1, leggere l'elenco `categories` e ottenere ogni `category` in cui il valore di `category` del campo `id` corrisponde al campo `annotation` dell'oggetto `category_id`.
1. Creare una riga JSON per l'immagine utilizzando gli oggetti `image`, `annotation` e `category` corrispondenti. Per mappare i campi, confrontare [Mappatura dei campi dell'oggetto COCO ai campi di un oggetto di riga JSON Custom Labels](#md-mapping-fields-coco).
1. Ripetere i passaggi da 1 a 3 fino a creare le righe JSON per ogni `image` oggetto della lista `images`.
Per il codice di esempio, consulta [Trasformazione di un set di dati COCO](md-coco-transform-example.md).
## Mappatura dei campi dell'oggetto COCO ai campi di un oggetto di riga JSON Custom Labels
Dopo aver identificato gli oggetti COCO per una riga JSON di Amazon Rekognition Custom Labels, si devono mappare i campi dell'oggetto COCO ai rispettivi campi di oggetto di riga JSON di Amazon Rekognition Custom Labels. L'esempio seguente di riga JSON di Amazon Rekognition Custom Labels mappa un'immagine (`id`=`000000245915`) al precedente esempio COCO JSON. Osservare le seguenti informazioni.
+ `source-ref` è la posizione dell'immagine in un bucket Amazon S3. Se le immagini COCO non sono archiviate in un bucket Amazon S3, è necessario spostarle in questo.
+ La lista`annotations` contiene un oggetto `annotation` per ogni oggetto dell'immagine. Un oggetto `annotation` include informazioni sul riquadro di delimitazione (`top`,`left`,`width`,`height`) e un identificatore di etichetta (`class_id`).
+ L'identificatore dell'etichetta (`class_id`) viene mappato alla lista `class-map` dei metadati. Elenca le etichette utilizzate nell'immagine.
```
{
"source-ref": "s3://custom-labels-bucket/images/000000245915.jpg",
"bounding-box": {
"image_size": {
"width": 640,
"height": 480,
"depth": 3
},
"annotations": [{
"class_id": 0,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}, {
"class_id": 1,
"top": 65,
"left": 86,
"width": 220,
"height": 334
}]
},
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
"class-map": {
"0": "Echo",
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
Utilizzare le seguenti informazioni per mappare i campi del file manifest di Amazon Rekognition Custom Labels ai campi JSON del set di dati COCO.
### source-ref
L'URL in formato S3 per la posizione dell'immagine. L’immagine deve essere archiviata in un bucket S3. Per ulteriori informazioni, consulta [source-ref](md-create-manifest-file-object-detection.md#cd-manifest-source-ref). Se il campo `coco_url` COCO punta a una posizione del bucket S3, si può utilizzare il valore di `coco_url` per il valore di `source-ref`. In alternativa, si può mappare `source-ref` il campo `file_name` (COCO) e aggiungere, nel codice di trasformazione, il percorso S3 richiesto in cui è archiviata l'immagine.
### *bounding-box*
Un nome di attributo dell'etichetta a scelta. Per ulteriori informazioni, consulta [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box).
#### image\$1size
Le dimensioni dell'immagine in pixel. Mappare su un `image` oggetto nell'elenco delle [immagini](md-coco-overview.md#md-coco-images).
+ `height`-> `image.height`
+ `width`-> `image.width`
+ `depth`-> Non utilizzare Amazon Rekognition Custom Labels, ma è necessario fornire un valore.
#### annotations
Elenco di oggetti `annotation`. C’è un’ `annotation` per ogni oggetto dell'immagine.
#### annotazione
Contiene informazioni sul riquadro di delimitazione per un'istanza di un oggetto dell'immagine.
+ `class_id`-> mappatura numerica degli ID della lista `class-map` di Custom Label.
+ `top` -> `bbox[1]`
+ `left` -> `bbox[0]`
+ `width` -> `bbox[2]`
+ `height` -> `bbox[3]`
### *bounding-box*-metadati
Metadati per l'attributo etichetta. Includere le etichette e gli identificatori delle etichette. Per ulteriori informazioni, consulta [*bounding-box*-metadati](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### Oggetti
Un array di oggetti nell’immagine. Mappare l'elenco `annotations` per indice.
##### Oggetto
+ `confidence`->Non utilizzato da Amazon Rekognition Custom Labels, ma è richiesto il valore (1).
#### class-map
Una mappa delle etichette (classi) che si applicano agli oggetti rilevati nell'immagine. Mappare gli oggetti delle categorie nell'elenco delle [categorie](md-coco-overview.md#md-coco-categories).
+ `id` -> `category.id`
+ `id value` -> `category.name`
#### tipo
Deve essere `groundtruth/object-detection`
#### annotato dall'uomo
Specificare `yes` o `no`. Per ulteriori informazioni, consulta [*bounding-box*-metadati](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### creation-date -> [image](md-coco-overview.md#md-coco-images) .date\$1capture
La data e l’ora di creazione dell’immagine. Mappare al campo [image](md-coco-overview.md#md-coco-images).date\$1capture di un'immagine nell'elenco delle immagini COCO. Amazon Rekognition Custom Labels prevede che il formato `creation-date` sia *Y-M-DTH:M:S*.
#### job-name
Un nome del lavoro a scelta.
# Il formato del set di dati COCO
Un set di dati COCO è composto da cinque sezioni di informazioni che forniscono informazioni per l'intero set di dati. Il formato per un set di dati di rilevamento dell’oggetto COCO è documentato in [COCO Data Format](http://cocodataset.org/#format-data).
+ info: informazioni generali sul set di dati.
+ licenses : informazioni sulla licenza per le immagini nel set di dati.
+ [images](#md-coco-images): un elenco di immagini nel set di dati.
+ [annotations](#md-coco-annotations): un elenco di annotazioni (compresi i riquadri di delimitazione) presenti in tutte le immagini del set di dati.
+ [categories:](#md-coco-categories) un elenco di categorie di etichette.
Per creare un manifest Custom Labels, utilizzare gli elenchi `images`, `annotations` e `categories` contenuti nel file manifest COCO. Le altre sezioni (`info`,`licences`) non sono obbligatorie. Di seguito è riportato un esempio del file manifest CSV.
```
{
"info": {
"description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
},
"licenses": [
{"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
],
"images": [
{"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
{"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
],
"annotations": [
{"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
{"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
{"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
],
"categories": [
{"supercategory": "speaker","id": 0,"name": "echo"},
{"supercategory": "speaker","id": 1,"name": "echo dot"}
]
}
```
## elenco di immagini
Le immagini a cui fa riferimento un set di dati COCO sono elencate nell'array di immagini. Ogni oggetto immagine contiene informazioni sull'immagine, come il nome del file di immagine. Nel seguente esempio di oggetto immagine, osservare le seguenti informazioni e quali campi sono necessari per creare un file manifest Amazon Rekognition Custom Labels.
+ `id`: (Obbligatorio) un identificatore univoco per l'immagine. Il campo `id` viene mappato nel campo `id` dell'array delle annotazioni (dove sono memorizzate le informazioni del riquadro di delimitazione).
+ `license`: (Non obbligatorio) mappare l'array di licenze.
+ `coco_url`: (Facoltativo) la posizione dell’immagine.
+ `flickr_url`: (Non obbligatorio) la posizione dell'immagine su Flickr.
+ `width`: (Obbligatorio) la larghezza dell'immagine.
+ `height`: (Obbligatorio) l'altezza dell'immagine.
+ `file_name`: (Obbligatorio) il nome del file di immagine. In questo esempio, `file_name` e `id` corrispondono, ma questo non è un requisito per i set di dati COCO.
+ `date_captured`: (Obbligatorio) la data e l'ora di acquisizione dell'immagine.
```
{
"id": 245915,
"license": 4,
"coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg",
"flickr_url": "http://farm1.staticflickr.com/88/nnnnnnnnnnnnnnnnnnn.jpg",
"width": 640,
"height": 480,
"file_name": "000000245915.jpg",
"date_captured": "2013-11-18 02:53:27"
}
```
## elenco delle annotazioni (riquadri di delimitazione)
Le informazioni dei riquadri di delimitazione per tutti gli oggetti su tutte le immagini vengono memorizzate nell'elenco delle annotazioni. Un singolo oggetto di annotazione contiene le informazioni del riquadro di delimitazione per un singolo oggetto e l'etichetta dell'oggetto in un'immagine. Esiste un oggetto di annotazione per ogni istanza di un oggetto in un'immagine.
Nell'esempio seguente, annotare le seguenti informazioni e quali campi sono necessari per creare un file manifest di Amazon Rekognition Custom Labels.
+ `id`: (Non obbligatorio) l'identificatore per l'annotazione.
+ `image_id`: (Obbligatorio) corrisponde all'immagine `id` nell'array di immagini.
+ `category_id`: (Obbligatorio) l'identificatore dell'etichetta che identifica l'oggetto all'interno di un riquadro di delimitazione. Viene mappato al campo `id` dell'array delle categorie.
+ `iscrowd`: (Non obbligatorio) specificare se l'immagine contiene un gruppo di oggetti.
+ `segmentation`: (Non obbligatorio) informazioni sulla segmentazione degli oggetti in un'immagine. Amazon Rekognition Custom Labels non supporta la segmentazione.
+ `area`: (Non obbligatorio) l'area dell'annotazione.
+ `bbox`: (Obbligatorio) contiene le coordinate in pixel di un riquadro di delimitazione attorno a un oggetto nell'immagine.
```
{
"id": 1409619,
"category_id": 1,
"iscrowd": 0,
"segmentation": [
[86.0, 238.8,..........382.74, 241.17]
],
"image_id": 245915,
"area": 3556.2197000000015,
"bbox": [86, 65, 220, 334]
}
```
## lista di categorie
Le informazioni sull'etichetta vengono memorizzate nell'array delle categorie. Nel seguente esempio di oggetto categoria, osservare le seguenti informazioni e quali campi sono necessari per creare un file manifest di Amazon Rekognition Custom Labels.
+ `supercategory`: (Non obbligatorio) la categoria principale di un'etichetta.
+ `id`: (Obbligatorio) l'identificatore dell'etichetta. Il campo `id` è mappato al campo `category_id` di un oggetto `annotation`. Nell'esempio seguente, l'identificatore di un echo dot è 2.
+ `name`: (Obbligatorio) il nome dell'etichetta.
```
{"supercategory": "speaker","id": 2,"name": "echo dot"}
```
# Trasformazione di un set di dati COCO
Usare il seguente esempio di Python per trasformare le informazioni del riquadro di delimitazione da un set di dati in formato COCO in un file manifest di Amazon Rekognition Custom Labels. Il codice carica il file manifest creato nel bucket Amazon S3. Il codice fornisce anche un comando AWS CLI che è possibile usare per caricare le immagini.
**Trasformare un set di dati COCO (SDK)**
1. Se non lo hai già fatto:
1. Accertarsi di avere le seguenti autorizzazioni `AmazonS3FullAccess`. Per ulteriori informazioni, consulta [Impostare le autorizzazioni dell’SDK](su-sdk-permissions.md).
1. 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. Usare il seguente codice Python per trasformare un set di dati COCO. Impostare i seguenti valori:
+ `s3_bucket`: il nome del bucket S3 in cui archiviare le immagini e il file manifest Amazon Rekognition Custom Labels.
+ `s3_key_path_images`: il percorso in cui si desiderano posizionare le immagini all'interno del bucket S3 (`s3_bucket`).
+ `s3_key_path_manifest_file`: il percorso in cui si desidera inserire il file manifest Custom Labels all'interno del bucket S3 (`s3_bucket`).
+ `local_path`: il percorso locale in cui l'esempio apre il set di dati COCO di input e salva anche il nuovo file manifest Custom Labels.
+ `local_images_path`: il percorso locale delle immagini che si desidera utilizzare per l'addestramento.
+ `coco_manifest`: il nome del file set di dati COCO di input.
+ `cl_manifest_file`: un nome per il file manifest creato dall'esempio. Il file viene salvato nella posizione specificata in `local_path`. Per convenzione, il file ha l'estensione`.manifest`, ma questa non è obbligatoria.
+ `job_name`: un nome per il lavoro Custom Labels.
```
import json
import os
import random
import shutil
import datetime
import botocore
import boto3
import PIL.Image as Image
import io
#S3 location for images
s3_bucket = 'bucket'
s3_key_path_manifest_file = 'path to custom labels manifest file/'
s3_key_path_images = 'path to images/'
s3_path='s3://' + s3_bucket + '/' + s3_key_path_images
s3 = boto3.resource('s3')
#Local file information
local_path='path to input COCO dataset and output Custom Labels manifest/'
local_images_path='path to COCO images/'
coco_manifest = 'COCO dataset JSON file name'
coco_json_file = local_path + coco_manifest
job_name='Custom Labels job name'
cl_manifest_file = 'custom_labels.manifest'
label_attribute ='bounding-box'
open(local_path + cl_manifest_file, 'w').close()
# class representing a Custom Label JSON line for an image
class cl_json_line:
def __init__(self,job, img):
#Get image info. Annotations are dealt with seperately
sizes=[]
image_size={}
image_size["width"] = img["width"]
image_size["depth"] = 3
image_size["height"] = img["height"]
sizes.append(image_size)
bounding_box={}
bounding_box["annotations"] = []
bounding_box["image_size"] = sizes
self.__dict__["source-ref"] = s3_path + img['file_name']
self.__dict__[job] = bounding_box
#get metadata
metadata = {}
metadata['job-name'] = job_name
metadata['class-map'] = {}
metadata['human-annotated']='yes'
metadata['objects'] = []
date_time_obj = datetime.datetime.strptime(img['date_captured'], '%Y-%m-%d %H:%M:%S')
metadata['creation-date']= date_time_obj.strftime('%Y-%m-%dT%H:%M:%S')
metadata['type']='groundtruth/object-detection'
self.__dict__[job + '-metadata'] = metadata
print("Getting image, annotations, and categories from COCO file...")
with open(coco_json_file) as f:
#Get custom label compatible info
js = json.load(f)
images = js['images']
categories = js['categories']
annotations = js['annotations']
print('Images: ' + str(len(images)))
print('annotations: ' + str(len(annotations)))
print('categories: ' + str(len (categories)))
print("Creating CL JSON lines...")
images_dict = {image['id']: cl_json_line(label_attribute, image) for image in images}
print('Parsing annotations...')
for annotation in annotations:
image=images_dict[annotation['image_id']]
cl_annotation = {}
cl_class_map={}
# get bounding box information
cl_bounding_box={}
cl_bounding_box['left'] = annotation['bbox'][0]
cl_bounding_box['top'] = annotation['bbox'][1]
cl_bounding_box['width'] = annotation['bbox'][2]
cl_bounding_box['height'] = annotation['bbox'][3]
cl_bounding_box['class_id'] = annotation['category_id']
getattr(image, label_attribute)['annotations'].append(cl_bounding_box)
for category in categories:
if annotation['category_id'] == category['id']:
getattr(image, label_attribute + '-metadata')['class-map'][category['id']]=category['name']
cl_object={}
cl_object['confidence'] = int(1) #not currently used by Custom Labels
getattr(image, label_attribute + '-metadata')['objects'].append(cl_object)
print('Done parsing annotations')
# Create manifest file.
print('Writing Custom Labels manifest...')
for im in images_dict.values():
with open(local_path+cl_manifest_file, 'a+') as outfile:
json.dump(im.__dict__,outfile)
outfile.write('\n')
outfile.close()
# Upload manifest file to S3 bucket.
print ('Uploading Custom Labels manifest file to S3 bucket')
print('Uploading' + local_path + cl_manifest_file + ' to ' + s3_key_path_manifest_file)
print(s3_bucket)
s3 = boto3.resource('s3')
s3.Bucket(s3_bucket).upload_file(local_path + cl_manifest_file, s3_key_path_manifest_file + cl_manifest_file)
# Print S3 URL to manifest file,
print ('S3 URL Path to manifest file. ')
print('\033[1m s3://' + s3_bucket + '/' + s3_key_path_manifest_file + cl_manifest_file + '\033[0m')
# Display aws s3 sync command.
print ('\nAWS CLI s3 sync command to upload your images to S3 bucket. ')
print ('\033[1m aws s3 sync ' + local_images_path + ' ' + s3_path + '\033[0m')
```
1. Eseguire il codice.
1. Di seguito è riportato un elenco dei comandi `s3 sync`. Questo valore servirà nella fase successiva.
1. Al prompt dei comandi, eseguire il comando `s3 sync`. Le immagini sono caricate nel bucket S3. Se il comando fallisce durante il caricamento, eseguirlo nuovamente finché le immagini locali non verranno sincronizzate con il bucket S3.
1. Nell'output del programma, osservare il percorso URL S3 del file manifest. Questo valore servirà nella fase successiva.
1. Seguire le istruzioni fornite in [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) per creare un set di dati con il file manifest caricato. Per il passaggio 8, nella **posizione del file.manifest**, inserire l'URL di Amazon S3 annotato nel passaggio precedente. Se si usa l' AWS SDK, fare [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).
# Trasformazione dei file manifest multietichetta di SageMaker AI Ground Truth
Questo argomento mostra come trasformare un file manifest multietichetta di Amazon SageMaker AI Ground Truth in un file manifest in formato Amazon Rekognition Custom Labels.
SageMaker I file manifest AI Ground Truth per lavori con più etichette sono formattati in modo diverso rispetto ai file manifest in formato Amazon Rekognition Custom Labels. La classificazione multietichetta si verifica quando un'immagine viene classificata in un insieme di classi, ma può appartenere a più di una contemporaneamente. In questo caso, l'immagine può potenzialmente avere più etichette (etichetta multipla), come *calcio* e *palla*.
Per informazioni sui lavori multietichetta di SageMaker AI Ground Truth, vedi [Image Classification (Multi-label](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html)). Per informazioni sui file manifest di Amazon Rekognition Custom Labels in formato multietichetta, consultare [Aggiungere più etichette a livello di immagine a un'immagine](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels).
## Ottenere il file manifest per un lavoro SageMaker AI Ground Truth
La procedura seguente mostra come ottenere il file manifest di output (`output.manifest`) per un job Amazon SageMaker AI Ground Truth. Usare `output.manifest` come input per la prossima procedura.
**Per scaricare un file di manifesto del lavoro di SageMaker AI Ground Truth**
1. Apri la [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Nel riquadro di navigazione, scegliere **Ground Truth**, quindi scegli **Labeling Jobs**.
1. Selezionare il processo di etichettatura che contiene il file manifest da utilizzare.
1. Nella pagina dei dettagli, scegliere il collegamento in **Posizione del set di dati di output**. La console Amazon S3 si apre nella posizione del set di dati.
1. Scegliere `Manifests`, `output` e poi `output.manifest`.
1. Per scaricare il file manifest, scegliere **Azioni oggetto** e poi **Scaricare**.
## Trasformazione di un file manifest SageMaker AI multietichetta
La procedura seguente crea un file manifest Amazon Rekognition Custom Labels in formato multietichetta da un file manifest AI in formato multietichetta esistente. SageMaker GroundTruth
**Nota**
Per eseguire il codice, è necessaria la versione 3 di Python o quella successiva.
**Per trasformare un file manifest AI multietichetta SageMaker**
1. Utilizzare il seguente codice Python. Specificare il nome del file manifest creato [Ottenere il file manifest per un lavoro SageMaker AI Ground Truth](#md-get-gt-manifest) come argomento della riga di comando.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to create and Amazon Rekognition Custom Labels format
manifest file from an Amazon SageMaker Ground Truth Image
Classification (Multi-label) format manifest file.
"""
import json
import logging
import argparse
import os.path
logger = logging.getLogger(__name__)
def create_manifest_file(ground_truth_manifest_file):
"""
Creates an Amazon Rekognition Custom Labels format manifest file from
an Amazon SageMaker Ground Truth Image Classification (Multi-label) format
manifest file.
:param: ground_truth_manifest_file: The name of the Ground Truth manifest file,
including the relative path.
:return: The name of the new Custom Labels manifest file.
"""
logger.info('Creating manifest file from %s', ground_truth_manifest_file)
new_manifest_file = f'custom_labels_{os.path.basename(ground_truth_manifest_file)}'
# Read the SageMaker Ground Truth manifest file into memory.
with open(ground_truth_manifest_file) as gt_file:
lines = gt_file.readlines()
#Iterate through the lines one at a time to generate the
#new lines for the Custom Labels manifest file.
with open(new_manifest_file, 'w') as the_new_file:
for line in lines:
#job_name - The of the Amazon Sagemaker Ground Truth job.
job_name = ''
# Load in the old json item from the Ground Truth manifest file
old_json = json.loads(line)
# Get the job name
keys = old_json.keys()
for key in keys:
if 'source-ref' not in key and '-metadata' not in key:
job_name = key
new_json = {}
# Set the location of the image
new_json['source-ref'] = old_json['source-ref']
# Temporarily store the list of labels
labels = old_json[job_name]
# Iterate through the labels and reformat to Custom Labels format
for index, label in enumerate(labels):
new_json[f'{job_name}{index}'] = index
metadata = {}
metadata['class-name'] = old_json[f'{job_name}-metadata']['class-map'][str(label)]
metadata['confidence'] = old_json[f'{job_name}-metadata']['confidence-map'][str(label)]
metadata['type'] = 'groundtruth/image-classification'
metadata['job-name'] = old_json[f'{job_name}-metadata']['job-name']
metadata['human-annotated'] = old_json[f'{job_name}-metadata']['human-annotated']
metadata['creation-date'] = old_json[f'{job_name}-metadata']['creation-date']
# Add the metadata to new json line
new_json[f'{job_name}{index}-metadata'] = metadata
# Write the current line to the json file
the_new_file.write(json.dumps(new_json))
the_new_file.write('\n')
logger.info('Created %s', new_manifest_file)
return new_manifest_file
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"manifest_file", help="The Amazon SageMaker Ground Truth manifest file"
"that you want to use."
)
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()
# Create the manifest file
manifest_file = create_manifest_file(args.manifest_file)
print(f'Manifest file created: {manifest_file}')
except FileNotFoundError as err:
logger.exception('File not found: %s', err)
print(f'File not found: {err}. Check your manifest file.')
if __name__ == "__main__":
main()
```
1. Annotare il nome del nuovo file manifesto visualizzato dallo script. Verrà usato nel prossimo passaggio.
1. [Carica i file manifest](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nel bucket Amazon S3 che si desidera utilizzare per archiviare il file manifest.
**Nota**
Assicurarsi che Amazon Rekognition Custom Labels abbia accesso al bucket Amazon S3 a cui si fa riferimento nel campo `source-ref` delle righe JSON del file manifest. Per ulteriori informazioni, consulta [Accesso a bucket Amazon S3 esterni](su-console-policy.md#su-external-buckets). Se il lavoro Ground Truth memorizza immagini nel bucket della console Amazon Rekognition Custom Labels, non è necessario aggiungere autorizzazioni.
1. Seguire le istruzioni riportate in [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) per creare un set di dati con il file manifest caricato. Per il passaggio 8, in **posizione del file.manifest**, inserire l'URL di Amazon S3 per la posizione del file manifest. Se si usa l' AWS SDK, fare [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).
# Creare un file manifest da CSV
Questo esempio di script Python semplifica la creazione di un file manifest utilizzando un file CSV (Comma Separated Values) per etichettare le immagini. Creare il file CSV. Il file manifest è adatto per la [classificazione di immagini multietichetta](getting-started.md#gs-multi-label-image-classification-example) o [Classificazione delle immagini multietichetta](getting-started.md#gs-multi-label-image-classification-example). Per ulteriori informazioni, consulta [Trova oggetti, scene e concetti](understanding-custom-labels.md#tm-classification).
**Nota**
Questo script non crea un file manifest adatto alla ricerca di [posizioni di oggetti](understanding-custom-labels.md#tm-object-localization) o di [posizione marchi](understanding-custom-labels.md#tm-brand-detection-localization).
Un file manifest descrive le immagini utilizzate per addestrare un modello. Ad esempio, le posizioni delle immagini e le etichette assegnate alle immagini. Un file manifest è costituito da una o più righe JSON. Ogni riga JSON descrive una singola immagine. Per ulteriori informazioni, consulta [Importazione di etichette a livello di immagine nei file manifest](md-create-manifest-file-classification.md).
Un file CSV rappresenta dati tabulari su più righe in un file di testo. I campi in una riga sono separati da una virgola. Per ulteriori informazioni, consulta [valori separati da virgola](https://en.wikipedia.org/wiki/Comma-separated_values). Per questo script, ogni riga del file CSV rappresenta una singola immagine ed è mappata a una riga JSON nel file manifest. Per creare un file CSV per un file manifest che supporti la [classificazione delle immagini multietichetta](getting-started.md#gs-multi-label-image-classification-example), aggiungere una o più etichette a livello di immagine in ciascuna riga. Per creare un file manifest adatto a [Classificazione delle immagini](getting-started.md#gs-image-classification-example), aggiungere una singola etichetta a livello di immagine in ciascuna riga.
Ad esempio, il seguente file CSV descrive le immagini del progetto [Classificazione delle immagini multietichetta](getting-started.md#gs-multi-label-image-classification-example) (Flowers) *Getting started*.
```
camellia1.jpg,camellia,with_leaves
camellia2.jpg,camellia,with_leaves
camellia3.jpg,camellia,without_leaves
helleborus1.jpg,helleborus,without_leaves,not_fully_grown
helleborus2.jpg,helleborus,with_leaves,fully_grown
helleborus3.jpg,helleborus,with_leaves,fully_grown
jonquil1.jpg,jonquil,with_leaves
jonquil2.jpg,jonquil,with_leaves
jonquil3.jpg,jonquil,with_leaves
jonquil4.jpg,jonquil,without_leaves
mauve_honey_myrtle1.jpg,mauve_honey_myrtle,without_leaves
mauve_honey_myrtle2.jpg,mauve_honey_myrtle,with_leaves
mauve_honey_myrtle3.jpg,mauve_honey_myrtle,with_leaves
mediterranean_spurge1.jpg,mediterranean_spurge,with_leaves
mediterranean_spurge2.jpg,mediterranean_spurge,without_leaves
```
Lo script genera righe JSON per ogni riga. Ad esempio, quanto segue è una riga JSON per la prima riga (`camellia1.jpg,camellia,with_leaves`).
```
{"source-ref": "s3://bucket/flowers/train/camellia1.jpg","camellia": 1,"camellia-metadata":{"confidence": 1,"job-name": "labeling-job/camellia","class-name": "camellia","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"},"with_leaves": 1,"with_leaves-metadata":{"confidence": 1,"job-name": "labeling-job/with_leaves","class-name": "with_leaves","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"}}
```
Nell'esempio CSV, il percorso di Amazon S3 per l'immagine non è presente. Se il file CSV non include il percorso Amazon S3 per le immagini, usare l'argomento `--s3_path` della riga di comando per specificare il percorso Amazon S3 dell'immagine.
Lo script registra la prima voce per ogni immagine in un file CSV di immagine deduplicato. Il file CSV di immagine deduplicata contiene una singola istanza di ogni immagine trovata nel file CSV di input. Le ulteriori occorrenze di un'immagine nel file CSV di input vengono registrate in un file CSV di immagine duplicato. Se lo script trova immagini duplicate, rivedere il file CSV di immagini duplicate e se necessario, aggiornarlo. Eseguire nuovamente lo script con il file deduplicato. Se non vengono trovati duplicati nel file CSV di input, lo script elimina il file CSV dell'immagine deduplicata e l'immagine duplicata, poiché sono vuoti. CSVfile
In questa procedura, creare il file CSV ed eseguire lo script Python per creare il file manifest.
**Creare un file manifest da un file CSV**
1. Crea un file CSV con i seguenti campi in ogni riga (una riga per immagine). Non aggiungere una riga di intestazione al file CSV.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/ex-csv-manifest.html)
Ad esempio, `camellia1.jpg,camellia,with_leaves` o `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves`
1. Salvare il file CSV.
1. Eseguire il seguente Python script. Fornire gli argomenti seguenti:
+ `csv_file`: il file CVS che si è creato nella fase 1.
+ `manifest_file`: il nome del file manifest che si desidera creare.
+ (Facoltativo)`--s3_path s3://path_to_folder/`: il percorso Amazon S3 da aggiungere ai nomi dei file immagine (campo 1). Utilizzare `--s3_path` se le immagini nel campo 1 non contengono già un percorso S3.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
from datetime import datetime, timezone
import argparse
import logging
import csv
import os
import json
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation.
Shows how to create an image-level (classification) manifest file from a CSV file.
You can specify multiple image level labels per image.
CSV file format is
image,label,label,..
If necessary, use the bucket argument to specify the S3 bucket folder for the images.
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-gt-cl-transform.html
"""
logger = logging.getLogger(__name__)
def check_duplicates(csv_file, deduplicated_file, duplicates_file):
"""
Checks for duplicate images in a CSV file. If duplicate images
are found, deduplicated_file is the deduplicated CSV file - only the first
occurence of a duplicate is recorded. Other duplicates are recorded in duplicates_file.
:param csv_file: The source CSV file.
:param deduplicated_file: The deduplicated CSV file to create. If no duplicates are found
this file is removed.
:param duplicates_file: The duplicate images CSV file to create. If no duplicates are found
this file is removed.
:return: True if duplicates are found, otherwise false.
"""
logger.info("Deduplicating %s", csv_file)
duplicates_found = False
# Find duplicates.
with open(csv_file, 'r', newline='', encoding="UTF-8") as f,\
open(deduplicated_file, 'w', encoding="UTF-8") as dedup,\
open(duplicates_file, 'w', encoding="UTF-8") as duplicates:
reader = csv.reader(f, delimiter=',')
dedup_writer = csv.writer(dedup)
duplicates_writer = csv.writer(duplicates)
entries = set()
for row in reader:
# Skip empty lines.
if not ''.join(row).strip():
continue
key = row[0]
if key not in entries:
dedup_writer.writerow(row)
entries.add(key)
else:
duplicates_writer.writerow(row)
duplicates_found = True
if duplicates_found:
logger.info("Duplicates found check %s", duplicates_file)
else:
os.remove(duplicates_file)
os.remove(deduplicated_file)
return duplicates_found
def create_manifest_file(csv_file, manifest_file, s3_path):
"""
Reads a CSV file and creates a Custom Labels classification manifest file.
:param csv_file: The source CSV file.
:param manifest_file: The name of the manifest file to create.
:param s3_path: The S3 path to the folder that contains the images.
"""
logger.info("Processing CSV file %s", csv_file)
image_count = 0
label_count = 0
with open(csv_file, newline='', encoding="UTF-8") as csvfile,\
open(manifest_file, "w", encoding="UTF-8") as output_file:
image_classifications = csv.reader(
csvfile, delimiter=',', quotechar='|')
# Process each row (image) in CSV file.
for row in image_classifications:
source_ref = str(s3_path)+row[0]
image_count += 1
# Create JSON for image source ref.
json_line = {}
json_line['source-ref'] = source_ref
# Process each image level label.
for index in range(1, len(row)):
image_level_label = row[index]
# Skip empty columns.
if image_level_label == '':
continue
label_count += 1
# Create the JSON line metadata.
json_line[image_level_label] = 1
metadata = {}
metadata['confidence'] = 1
metadata['job-name'] = 'labeling-job/' + image_level_label
metadata['class-name'] = image_level_label
metadata['human-annotated'] = "yes"
metadata['creation-date'] = \
datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')
metadata['type'] = "groundtruth/image-classification"
json_line[f'{image_level_label}-metadata'] = metadata
# Write the image JSON Line.
output_file.write(json.dumps(json_line))
output_file.write('\n')
output_file.close()
logger.info("Finished creating manifest file %s\nImages: %s\nLabels: %s",
manifest_file, image_count, label_count)
return image_count, label_count
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"csv_file", help="The CSV file that you want to process."
)
parser.add_argument(
"--s3_path", help="The S3 bucket and folder path for the images."
" If not supplied, column 1 is assumed to include the S3 path.", required=False
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# Get command line arguments
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
s3_path = args.s3_path
if s3_path is None:
s3_path = ''
# Create file names.
csv_file = args.csv_file
file_name = os.path.splitext(csv_file)[0]
manifest_file = f'{file_name}.manifest'
duplicates_file = f'{file_name}-duplicates.csv'
deduplicated_file = f'{file_name}-deduplicated.csv'
# Create manifest file, if there are no duplicate images.
if check_duplicates(csv_file, deduplicated_file, duplicates_file):
print(f"Duplicates found. Use {duplicates_file} to view duplicates "
f"and then update {deduplicated_file}. ")
print(f"{deduplicated_file} contains the first occurence of a duplicate. "
"Update as necessary with the correct label information.")
print(f"Re-run the script with {deduplicated_file}")
else:
print("No duplicates found. Creating manifest file.")
image_count, label_count = create_manifest_file(csv_file,
manifest_file,
s3_path)
print(f"Finished creating manifest file: {manifest_file} \n"
f"Images: {image_count}\nLabels: {label_count}")
except FileNotFoundError as err:
logger.exception("File not found: %s", err)
print(f"File not found: {err}. Check your input CSV file.")
if __name__ == "__main__":
main()
```
1. Se si vuole utilizzare un set di dati di test, ripetere i passaggi da 1 a 3 per creare un file manifest per il set di dati di test.
1. Se necessario, copiare le immagini nel percorso del bucket Amazon S3 specificato nella colonna 1 del file CSV (o specificato nella riga di comando `--s3_path`). Utilizzare il seguente comando AWS S3.
```
aws s3 cp --recursive your-local-folder s3://your-target-S3-location
```
1. [Carica i file manifest](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nel bucket Amazon S3 che si desidera utilizzare per archiviare il file manifest.
**Nota**
Assicurarsi che Amazon Rekognition Custom Labels abbia accesso al bucket Amazon S3 a cui si fa riferimento nel campo `source-ref` delle righe JSON del file manifest. Per ulteriori informazioni, consulta [Accesso a bucket Amazon S3 esterni](su-console-policy.md#su-external-buckets). Se il lavoro Ground Truth memorizza immagini nel bucket della console Amazon Rekognition Custom Labels, non è necessario aggiungere autorizzazioni.
1. Seguire le istruzioni riportate in [Creazione di un set di dati con un file manifest SageMaker AI Ground Truth (Console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) per creare un set di dati con il file manifest caricato. Per il passaggio 8, in **posizione del file.manifest**, inserire l'URL di Amazon S3 per la posizione del file manifest. Se si usa l' AWS SDK, fare [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).
# Copia del contenuto da un set di dati esistente
Se è già stato creato un set di dati, si può copiarne il contenuto in uno nuovo. Per creare un set di dati da un set di dati esistente con l' AWS SDK, consulta. [Creazione di un set di dati utilizzando un set di dati esistente (SDK)](md-create-dataset-existing-dataset-sdk.md)
**Creare un set di dati utilizzandone uno esistente di Amazon Rekognition Custom Labels (console)**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Scegli **Usa etichette personalizzate**.
1. Scegli **Avvia**.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**.
1. Nella pagina **Progetti**, scegliere il progetto a cui aggiungere un set di dati. Viene visualizzata la pagina dei dettagli del progetto.
1. Scegli **Crea set di dati**. Viene visualizzata la pagina **Creare set di dati**.
1. In **Configurazione iniziale**, scegliere **Iniziare con un singolo set di dati** o **Iniziare con un set di dati di addestramento**. Per creare un modello di qualità superiore, consigliamo di iniziare con set di dati di addestramento e test separati.
------
#### [ Single dataset ]
1. Nella sezione **Dettagli del set di dati di addestramento**, scegliere **Copiare un set di dati Amazon Rekognition Custom Labels esistente**.
1. Nella sezione **Dettagli del set di dati di addestramento**, nella casella di modifica del **set di dati**, digitare o selezionare il nome del set di dati che si vuole copiare.
1. Scegli **Crea set di dati**. Si apre la pagina dei set di dati per il progetto.
------
#### [ Separate training and test datasets ]
1. Nella sezione **Dettagli del set di dati di addestramento**, scegliere **Copiare un set di dati Amazon Rekognition Custom Labels esistente**.
1. Nella sezione **Dettagli del set di dati di addestramento**, nella casella di modifica del **set di dati**, digitare o selezionare il nome del set di dati che si vuole copiare.
1. Nella sezione **Dettagli del set di dati di test**, scegliere **Copiare un set di dati Amazon Rekognition Custom Labels esistente**.
1. Nella sezione **Dettagli del set di dati di test**, nella casella di modifica del **set di dati**, digitare o selezionare il nome del set di dati che si vuole copiare.
**Nota**
I set di dati di addestramento e test possono avere diverse fonti di immagini.
1. Scegli **Crea database**. Si apre la pagina dei set di dati per il progetto.
------
1. Se si deve aggiungere o modificare etichette, fare [Immagini etichettate](md-labeling-images.md).
1. Seguire i passaggi indicati in [Addestramento di un modello (Console)](training-model.md#tm-console) per addestrare il modello.