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
Un set di dati è un insieme di immagini ed etichette che descrivono queste immagini. Il progetto richiede un set di dati di formazione e uno di test. Amazon Rekognition Custom Labels utilizza il set di dati di addestramento per addestrare il tuo modello. Dopo l’addestramento, Amazon Rekognition Custom Labels utilizza il set di dati di test per verificare la capacità del modello addestrato di prevedere le etichette corrette.
Puoi creare set di dati con la console Amazon Rekognition Custom Labels o con l'SDK. AWS Prima di creare un set di dati, ti consigliamo di leggere [Informazioni su etichette personalizzate Amazon Rekognition](understanding-custom-labels.md). Per altre attività relative al set di dati, confrontare [Gestione di set di dati](managing-dataset.md).
I passaggi per creare un set di dati di addestramento e test per un progetto sono:
**Creare set di dati di addestramento e test per il progetto**
1. Determinare come etichettare i set di dati di addestramento e test. Per ulteriori informazioni, consultare [Formattazione di set di dati](md-dataset-purpose.md).
1. Raccogliere le immagini per i set di dati di addestramento e test. Per ulteriori informazioni, consulta [Preparazione delle immagini](md-prepare-images.md).
1. Creare i set di dati di addestramento e test. Per ulteriori informazioni, consulta [Creazione di set di dati di addestramento e test con immagini](md-create-dataset.md). Se utilizzi l'SDK, consulta. AWS [Creare set di dati di addestramento e test (SDK)](md-create-dataset.md#cd-create-dataset-sdk)
1. Se necessario, aggiungere etichette o riquadri di delimitazione a livello di immagine alle immagini del set di dati. Per ulteriori informazioni, consulta [Immagini etichettate](md-labeling-images.md).
Dopo aver creato i set di dati, [addestrare](training-model.md) il modello.
**Topics**
+ [Formattazione di set di dati](md-dataset-purpose.md)
+ [Preparazione delle immagini](md-prepare-images.md)
+ [Creazione di set di dati di addestramento e test con immagini](md-create-dataset.md)
+ [Immagini etichettate](md-labeling-images.md)
+ [Debugging set di dati](debugging-datasets.md)
# Formattazione di set di dati
Il modo in cui si etichettano i set di dati di addestramento e test del progetto determinano il tipo di modello che si crea. Con Amazon Rekognition Custom Labels si possono creare modelli che eseguono le seguenti operazioni.
+ [Trova oggetti, scene e concetti](#md-dataset-purpose-classification)
+ [Trova le posizioni degli oggetti](#md-dataset-purpose-localization)
+ [Trovare le posizioni dei marchi](#md-dataset-purpose-brands)
## Trova oggetti, scene e concetti
Il modello classifica gli oggetti, le scene e i concetti associati a un'intera immagine.
È possibile creare due tipi di modello di classificazione, la *classificazione delle immagini* e la *classificazione multietichetta*. Per entrambi i tipi di modello di classificazione, il modello trova una o più etichette corrispondenti dal set completo di etichette utilizzato per l’addestramento. I set di dati di addestramento e test richiedono entrambi almeno due etichette.
### Classificazione delle immagini
Il modello classifica le immagini come appartenenti a un set di etichette predefinite. Ad esempio, si potrebbe scegliere un modello che determini se un'immagine contiene uno spazio abitativo. L'immagine seguente potrebbe avere un'etichetta a livello di immagine *living\$1space*.
![\[Accogliente soggiorno con camino, ampie finestre che si affacciano sul patio del cortile. Toni neutri, accenti in legno.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/living_space1.jpeg)
Per questo tipo di modello, aggiungere una singola etichetta a livello di immagine a ciascuna delle immagini del set di dati di addestramento e test. Per un progetto di esempio, consulta [Classificazione delle immagini](getting-started.md#gs-image-classification-example).
### Classificazione multietichetta
Il modello classifica le immagini in più categorie, ad esempio il tipo di fiore e se ha foglie o meno. Ad esempio, l'immagine seguente potrebbe avere etichette a livello di immagine *mediterranean\$1spurge* e *no\$1leaves*.
![\[Primo piano di un grappolo di fiori di viburno verde con piccoli fiori ben confezionati.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/mediterranean_spurge3.jpg)
Per questo tipo di modello, assegnare etichette a livello di immagine a ogni categoria di immagini dei set di dati di addestramento e test. Per un progetto di esempio, consulta [Classificazione delle immagini multietichetta](getting-started.md#gs-multi-label-image-classification-example).
### Assegnazione di etichette a livello di immagine
Se le immagini sono archiviate in un bucket Amazon S3, si può utilizzare i [nomi delle cartelle](md-create-dataset-s3.md) per aggiungere automaticamente etichette a livello di immagine. Per ulteriori informazioni, consultare [Importazione di immagini da un bucket Amazon S3](md-create-dataset-s3.md). Si può anche aggiungere etichette a livello di immagine alle immagini dopo aver creato un set di dati. Per ulteriori informazioni, consulta [Assegnazione di etichette a livello di immagine a un'immagine](md-assign-image-level-labels.md). Si possono aggiungere nuove etichette quando se ne ha bisogno. Per ulteriori informazioni, consulta [Gestione etichette](md-labels.md).
## Trova le posizioni degli oggetti
Per creare un modello che preveda la posizione degli oggetti nelle immagini, definire i riquadri di delimitazione e le etichette per le immagini nei set di dati di addestramento e test. Un riquadro di delimitazione è un riquadro che circonda strettamente un oggetto. Ad esempio, l'immagine seguente mostra dei riquadri di delimitazione attorno a Amazon Echo e Amazon Echo Dot. A ogni riquadro di delimitazione è assegnata un'etichetta (*Amazon Echo* o *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)
Per trovare le posizioni degli oggetti, i set di dati necessitano di almeno un'etichetta. Durante l'addestramento del modello, viene creata automaticamente un'ulteriore etichetta che rappresenta l'area esterna ai riquadri di delimitazione di un'immagine.
### Assegnazione di riquadri di delimitazione
Quando si crea il set di dati, si possono includere informazioni sui riquadri di delimitazione per le tue immagini. Ad esempio, puoi importare un [file manifest](md-create-manifest-file.md) in formato SageMaker AI Ground Truth che contiene riquadri di delimitazione. È inoltre possibile aggiungere riquadri di delimitazione dopo aver creato un set di dati. Per ulteriori informazioni, consulta [Etichettatura degli oggetti con riquadri di delimitazione](md-localize-objects.md). Si possono aggiungere nuove etichette quando se ne ha bisogno. Per ulteriori informazioni, consulta [Gestione etichette](md-labels.md).
## Trovare le posizioni dei marchi
Se si desidera trovare la posizione dei marchi, ad esempio loghi e personaggi animati, si possono utilizzare due diversi tipi di immagini per quelle dei tuoi set di dati di allenamento.
+ Immagini che rappresentano solo il logo. Ogni immagine necessita di un'unica etichetta a livello di immagine che rappresenti il nome del logo. Ad esempio, l'etichetta a livello di immagine per l'immagine di seguito potrebbe essere *Lambda.*
![\[Logo Lambda in bianco su sfondo arancione.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/lambda-logo.jpg)
+ Immagini che contengono il logo di luoghi naturali, come una partita di calcio o uno schema architettonico. Ogni immagine di addestramento necessita di riquadri di delimitazione che circondano ogni istanza del logo. Ad esempio, l'immagine seguente mostra un diagramma architettonico con riquadri di delimitazione etichettati che circondano i loghi Lambda AWS e Amazon Pinpoint.
![\[Diagrom del flusso di lavoro che mostra il servizio AWS Lambda che inserisce l'attività degli utenti in Amazon Pinpoint per ottenere consigli.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/brand-detection-lambda.png)
Consigliamo di non mischiare etichette a livello di immagine e riquadri di delimitazione nelle immagini di addestramento.
Le immagini di test devono avere dei riquadri di delimitazione attorno alle istanze del marchio che si desidera trovare. Si può dividere il set di dati di addestramento per creare quello di test, solo se le immagini di addestramento includono riquadri di delimitazione etichettati. Se le immagini di addestramento hanno solo etichette a livello di immagine, è necessario creare un set di dati di test che includa immagini con riquadri di delimitazione etichettati. Se si addestra un modello per trovare le posizioni dei marchi, farlo con in [Etichettatura degli oggetti con riquadri di delimitazione](md-localize-objects.md) e [Assegnazione di etichette a livello di immagine a un'immagine](md-assign-image-level-labels.md) a seconda di come si etichettano le immagini.
Il progetto di esempio [Rilevamento di marchi](getting-started.md#gs-brand-detection-example) mostra come Amazon Rekognition Custom Labels utilizza riquadri di delimitazione etichettati per addestrare un modello che trova le posizioni degli oggetti.
## Requisiti di etichettatura per i tipi di modello
Utilizzare la tabella seguente per stabilire come etichettare le immagini.
È possibile unire etichette a livello di immagine e immagini etichettate con riquadro di delimitazione in un unico set di dati. In questo caso, Amazon Rekognition Custom Labels sceglie se creare un modello a livello di immagine o un modello di posizione degli oggetti.
| Esempio | Immagini di addestramento | Immagini di test |
| --- | --- | --- |
| [Classificazione delle immagini](#md-dataset-image-classification) | 1 etichetta a livello di immagine per immagine | 1 etichetta a livello di immagine per immagine |
| [Classificazione multietichetta](#md-dataset-image-classification-multi-label) | Più etichette a livello di immagine per immagine | Più etichette a livello di immagine per immagine |
| [Trovare le posizioni dei marchi](#md-dataset-purpose-brands) | etichette a livello di immagine (puoi anche utilizzare riquadri di delimitazione etichettati) | Riquadri di delimitazione etichettati |
| [Trova le posizioni degli oggetti](#md-dataset-purpose-localization) | Riquadri di delimitazione etichettati | Riquadri di delimitazione etichettati |
# Preparazione delle immagini
Le immagini nel set di dati di addestramento e test contengono gli oggetti, le scene o i concetti che si desidera che il modello individui.
Il contenuto delle immagini deve avere una varietà di sfondi e luci che rappresentano le immagini che si desidera vengano individuate dal modello addestrato.
Questa sezione contiene informazioni relative alle immagini del set di dati di addestramento e test.
## Formato di immagine
Si possono addestrare i modelli di Amazon Rekognition Custom Labels con immagini in formato PNG e JPEG. Analogamente, per rilevare l'utilizzo di etichette personalizzate`DetectCustomLabels`, sono necessarie immagini in formato PNG e JPEG.
## Suggerimenti per le immagini di input
Amazon Rekognition Custom Labels richiede immagini per addestrare e testare il modello. Per preparare le immagini, considerare quanto segue:
+ Scegliere un dominio specifico per il modello che si desidera creare. Ad esempio, si può scegliere un modello per viste panoramiche e un altro per oggetti come parti di macchine. Amazon Rekognition Custom Labels funziona meglio se le immagini si trovano nel dominio selezionato.
+ Usare almeno 10 immagini per addestrare il tuo modello.
+ Le immagini devono essere in formato PNG o JPEG.
+ Usare immagini che mostrino l'oggetto con una varietà di luci, sfondi e risoluzioni.
+ Le immagini di addestramento e test devono essere simili a quelle con cui si desidera utilizzare il modello.
+ Decidere quali etichette assegnare alle immagini.
+ Assicurarsi che le immagini abbiano una risoluzione sufficientemente grande. Per ulteriori informazioni, consulta [Linee guida e quote in etichette personalizzate Amazon Rekognition](limits.md).
+ Assicurarsi che le occlusioni non oscurino gli oggetti che si desidera rilevare.
+ Utilizzare immagini che abbiano un contrasto sufficiente con lo sfondo.
+ Utilizzare immagini luminose e nitide. Evitare il più possibile di utilizzare immagini che potrebbero essere sfocate a causa del soggetto e del movimento della fotocamera.
+ Utilizzare un'immagine in cui l'oggetto ne occupa una gran parte.
+ Le immagini nel set di dati di test non devono essere immagini che si trovano in quello di addestramento. Dovrebbero includere gli oggetti, le scene e i concetti che il modello è addestrato ad analizzare.
## Dimensioni del set di immagini
Amazon Rekognition Custom Labels utilizza un set di immagini per addestrare un modello. Si dovrebbero usare almeno 10 immagini per l'addestramento. Amazon Rekognition Custom Labels archivia immagini di addestramento e test nel set di dati. Per ulteriori informazioni, consulta [Creazione di set di dati di addestramento e test con immagini](md-create-dataset.md).
# 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.
# Immagini etichettate
Un'etichetta identifica un oggetto, una scena, un concetto o un riquadro di delimitazione attorno a un oggetto in un'immagine. Ad esempio, se il set di dati contiene immagini di cani, si possono aggiungere etichette per razze di cani.
Dopo aver importato le immagini in un set di dati, potrebbe essere necessario aggiungere etichette alle immagini o correggere quelle con etichette errate. Ad esempio, le immagini non vengono etichettate se importate da un computer locale. La galleria di set di dati viene utilizzata per aggiungere nuove etichette al set di dati e assegnare immagini e riquadri di selezione alle immagini del set di dati.
Il modo in cui vengono etichettate le immagini nei set di dati determina il tipo di modello che Amazon Rekognition Custom Labels addestra. Per ulteriori informazioni, consulta [Formattazione di set di dati](md-dataset-purpose.md).
**Topics**
+ [Gestione etichette](md-labels.md)
+ [Assegnazione di etichette a livello di immagine a un'immagine](md-assign-image-level-labels.md)
+ [Etichettatura degli oggetti con riquadri di delimitazione](md-localize-objects.md)
# Gestione etichette
Si possono gestire le etichette utilizzando la console Amazon Rekognition Custom Labels. Non esiste un'API specifico per la gestione delle etichette: le etichette vengono aggiunte al set di dati quando lo si crea con `CreateDataset` o quando si aggiungono altre immagini al set di dati con `UpdateDatasetEntries`.
**Topics**
+ [Gestione etichette (Console)](#md-labels-console)
+ [Gestione etichette (SDK)](#md-labels-sdk)
## Gestione etichette (Console)
Si può utilizzare la console Amazon Rekognition Custom Labels per aggiungere, modificare o rimuovere etichette da un set di dati. Per aggiungere un'etichetta a un set di dati, se ne può aggiungere una per creare o importare etichette da un set di dati esistente in Rekognition.
**Topics**
+ [Aggiungere nuove etichette (Console)](#md-add-new-labels)
+ [Modificare e rimuovere le etichette (Console)](#md-edit-labels-after-adding)
### Aggiungere nuove etichette (Console)
Si possono specificare nuove etichette da aggiungere al set di dati.
#### Aggiungere etichette utilizzando la finestra di modifica
**Aggiungere una nuova etichetta (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 da usare. Viene visualizzata la pagina dei dettagli del progetto.
1. Se si desidera aggiungere etichette al set di dati di addestramento, scegliere la scheda **Addestramento**. Altrimenti scegliere la scheda **Test** per aggiungere etichette al set di dati del test.
1. Scegli **Avvia etichettatura** per accedere alla modalità di etichettatura.
1. Nella sezione **Etichette** della galleria di set di dati, scegliere **Gestisci etichette** per aprire la finestra di dialogo **Gestisci etichette**.
1. Nella casella di modifica, inserisci un nuovo nome per l'etichetta.
1. Scegli **Aggiungi etichetta**.
1. Ripeti i passaggi 9 e 10 fino a creare tutte le etichette necessarie.
1. Scegli **Salva** per salvare le etichette che hai aggiunto.
### Modificare e rimuovere le etichette (Console)
È possibile rinominare o rimuovere le etichette dopo averle aggiunte a un set di dati. È possibile rimuovere solo le etichette che non sono assegnate a nessuna immagine.
**Rinominare o rimuovere un'etichetta esistente (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 da usare. Viene visualizzata la pagina dei dettagli del progetto.
1. Se si desidera modificare o eliminare le etichette nel tuo set di dati di addestramento, scegliere la scheda **Addestramento**. Altrimenti, scegliere la scheda **Test** per modificare o eliminare le etichette dal set di dati del test.
1. Scegli **Avvia etichettatura** per accedere alla modalità di etichettatura.
1. Nella sezione **Etichette** della galleria di set di dati, scegliere **Gestisci etichette** per aprire la finestra di dialogo **Gestisci etichette**.
1. Scegliere l’etichetta da modificare o eliminare.
![\[Finestra di dialogo per la gestione delle etichette che mostra un campo di testo per aggiungere una nuova etichetta e un'etichetta esistente denominata «test», con opzioni per salvare o annullare le modifiche.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/change-delete-label.jpg)
1. Se si sceglie l'icona di eliminazione (X), l'etichetta viene rimossa dall'elenco.
1. Se si desidera cambiare l'etichetta, scegliere l'icona di modifica (matita e paper pad) e inserire un nuovo nome per l'etichetta nella casella di modifica.
1. Scegliere **Salva** per salvare le modifiche.
## Gestione etichette (SDK)
Non esiste un'API unico che gestisca le etichette dei set di dati. Se si crea un set di dati con `CreateDataset` le etichette presenti nel file manifest o nel set di dati copiato, creare il set iniziale di etichette. Se si aggiungono altre immagini con l'API `UpdateDatasetEntries`, le nuove etichette presenti nelle voci vengono aggiunte al set di dati. Per ulteriori informazioni, consulta [Aggiungere altre immagini (SDK)](md-add-images.md#md-add-images-sdk). Per eliminare le etichette da un set di dati, è necessario rimuovere tutte le annotazioni delle etichette nel set di dati.
**Eliminazione di etichette da un set di dati**
1. Chiamare `ListDatasetEntries` per ottenere le voci del set di dati. Per il codice di esempio, consulta [Elencare le voci del set di dati (SDK)](md-listing-dataset-entries-sdk.md).
1. Nel file, rimuovere tutte le annotazioni sull'etichetta. Per ulteriori informazioni, consulta [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).
1. Usare il file per aggiornare il set di dati con l'API `UpdateDatasetEntries`. Per ulteriori informazioni, consulta [Aggiungere altre immagini (SDK)](md-add-images.md#md-add-images-sdk).
# Assegnazione di etichette a livello di immagine a un'immagine
Utilizzare etichette a livello di immagine per addestrare modelli che classificano le immagini in categorie. Un'etichetta a livello di immagine indica se un'immagine contiene un oggetto, una scena o un concetto. Per esempio, la seguente immagine mostra un fiume. Se il modello classifica le immagini come contenenti fiumi, è necessario aggiungere un'etichetta *fiume*a livello di immagine. Per ulteriori informazioni, consulta [Formattazione di set di dati](md-dataset-purpose.md).
![\[Lago che riflette montagne e nuvole nell'acqua ferma al tramonto o all'alba.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/pateros.jpg)
Un set di dati che contiene etichette a livello di immagine necessita della definizione di almeno due etichette. Ogni immagine necessita di almeno un'etichetta assegnata che identifichi l'oggetto, la scena o il concetto nell'immagine.
**Assegnare etichette a livello di immagine a un'immagine (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 da usare. Viene visualizzata la pagina dei dettagli del progetto.
1. **Nel riquadro di navigazione a sinistra, scegli Dataset.**
1. Se si desidera aggiungere etichette al set di dati di addestramento, scegliere la scheda **Addestramento**. Altrimenti scegliere la scheda **Test** per aggiungere etichette al set di dati del test.
1. Scegli **Avvia etichettatura** per accedere alla modalità di etichettatura.
1. Nella galleria di immagini, selezionare una o più immagini a cui si vuole aggiungere etichette. È possibile selezionare immagini su una sola pagina alla volta. Per selezionare un intervallo contiguo di immagini su una pagina:
1. Seleziona la prima immagine dell'intervallo.
1. Tieni premuto il tasto shift.
1. Selezionare l'ultimo intervallo di immagini. Vengono selezionate anche le immagini tra la prima e la seconda immagine.
1. Rilascia il tasto shift.
1. Scegli **Assegna etichette a livello di immagine**.
1. Nella finestra di dialogo **Assegna un'etichetta a livello di immagine alle immagini selezionate**, selezionate un'etichetta da assegnare all'immagine o alle immagini.
1. Sceglie **Assegna** per assegnare un'etichetta all'immagine.
1. Ripeti l'etichettatura finché ogni immagine non viene annotata con le etichette richieste.
1. Per salvare le modifiche, scegliere **Salva modifiche**.
## Assegnare etichette a livello di immagine (SDK)
Si può utilizzare l'API `UpdateDatasetEntries` per aggiungere o aggiornare le etichette a livello di immagine assegnate a un'immagine. `UpdateDatasetEntries` richiedere una o più righe JSON. Ogni riga JSON rappresenta una singola immagine. Per un'immagine con un'etichetta a livello di immagine, la riga JSON è simile alla seguente.
```
{"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"}}
```
Il campo `source-ref` indica la posizione dell'immagine. La riga JSON include anche le etichette a livello di immagine, assegnate. Per ulteriori informazioni, consulta [Importazione di etichette a livello di immagine nei file manifest](md-create-manifest-file-classification.md).
**Assegnare etichette a livello di immagine a un'immagine**
1. Ottenere la riga get JSON per l'immagine esistente utilizzando `ListDatasetEntries`. Per il campo `source-ref`, specificare la posizione dell'immagine a cui si vuole assegnare l'etichetta. Per ulteriori informazioni, consulta [Elencare le voci del set di dati (SDK)](md-listing-dataset-entries-sdk.md).
1. Aggiornare la riga JSON restituita nel passaggio precedente utilizzando le informazioni disponibili in [Importazione di etichette a livello di immagine nei file manifest](md-create-manifest-file-classification.md).
1. Chiamare `UpdateDatasetEntries` per aggiornare l'immagine. Per ulteriori informazioni, consulta [Aggiungere altre immagini a un set di dati](md-add-images.md).
# Etichettatura degli oggetti con riquadri di delimitazione
Se si desidera che il modello rilevi la posizione degli oggetti all'interno di un'immagine, si deve identificare cos'è l'oggetto e dove si trova nell'immagine. Un riquadro di delimitazione è un riquadro che isola un oggetto in un'immagine. Si utilizzano i riquadri di delimitazione per addestrare un modello a rilevare oggetti diversi nella stessa immagine. L'oggetto viene identificato assegnando un'etichetta al riquadro di delimitazione.
**Nota**
Se si sta addestrando un modello a trovare oggetti, scene e concetti con etichette a livello di immagine, non è necessario eseguire questo passaggio.
Ad esempio, se si desidera addestrare un modello che rilevi i dispositivi Amazon Echo Dot, disegnare un riquadro di delimitazione attorno a ogni Echo Dot in un'immagine e assegnare un'etichetta denominata *Echo Dot* al riquadro di selezione. L'immagine seguente mostra un riquadro di delimitazione attorno a un dispositivo Echo Dot. L'immagine contiene anche un Amazon Echo senza un riquadro di delimitazione.
![\[Dispositivi Amazon Echo Dot ed Echo, con bounding box attorno a Echo Dot.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/dot.jpg)
## Posizionare gli oggetti con riquadri di delimitazione (Console)
In questa procedura, utilizzare la console per disegnare riquadri di delimitazione attorno agli oggetti delle immagini. È inoltre possibile identificare gli oggetti all'interno dell'immagine, assegnando etichette al riquadro di delimitazione.
**Nota**
Non si può usare il browser Safari per aggiungere riquadri di selezione alle immagini. Per i browser supportati, vedere [Configurazione di Amazon Rekognition Custom Labels](setting-up.md).
Prima di aggiungere riquadri di delimitazione, è necessario aggiungere almeno un'etichetta al set di dati. Per ulteriori informazioni, consulta [Aggiungere nuove etichette (Console)](md-labels.md#md-add-new-labels).
****
**Aggiungere riquadri di delimitazione alle immagini (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 da usare. Viene visualizzata la pagina dei dettagli del progetto.
1. Nella pagina dei dettagli del progetto, scegliere **Etichetta immagini**
1. Se si desidera aggiungere riquadri di delimitazione alle immagini del set di dati di addestramento, scegliere la scheda **Addestramento**. Altrimenti scegliere la scheda **Test** per aggiungere riquadri di delimitazione alle immagini del set di dati di test.
1. Scegli **Avvia etichettatura** per accedere alla modalità di etichettatura.
1. Nella galleria di immagini, scegliere le immagini a cui si vogliono aggiungere i riquadri di delimitazione.
1. Scegliere **Disegnare riquadro di delimitazione**. Prima che venga visualizzato l'editor del riquadro di delimitazione, viene visualizzata una serie di suggerimenti.
1. Nel riquadro **Etichette** a destra, selezionare l'etichetta che si desidera assegnare a un riquadro di delimitazione.
1. Nello strumento di disegno, posizionare il puntatore nell'area superiore sinistra dell'oggetto desiderato.
1. Premere il pulsante sinistro del mouse e disegnare un riquadro attorno all'oggetto. Cercare di disegnare il riquadro di delimitazione il più vicino possibile all'oggetto.
1. Rilasciare il pulsante del mouse. Il riquadro di delimitazione è evidenziato.
1. Scegliere **Avanti** se ci sono altre immagini da etichettare. Altrimenti, scegliere **Fine** per completare l'etichettatura.
![\[Interfaccia utente per disegnare un riquadro di delimitazione attorno a un'immagine, l'immagine sono gli altoparlanti intelligenti Amazon Echo ed Echo Dot su una superficie di legno.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/draw-bounding-box.png)
1. Ripetere i passaggi da 1 a 7 fino a creare un riquadro di selezione in ogni immagine che contiene oggetti.
1. Per salvare le modifiche, scegliere **Salva modifiche**.
1. Scegliere **Esci** per uscire dalla modalità di etichettatura.
## Individuare gli oggetti con riquadri di delimitazione (SDK)
Si può utilizzare l'API `UpdateDatasetEntries` per aggiungere o aggiornare le informazioni sulla posizione degli oggetti per un'immagine. `UpdateDatasetEntries` richiede una o più righe JSON. Ogni riga JSON rappresenta una singola immagine. Per la localizzazione degli oggetti, una riga JSON è simile alla seguente.
```
{"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"}}
```
Il campo `source-ref` indica la posizione dell'immagine. La riga JSON include anche riquadri di delimitazione etichettati per ogni oggetto nell'immagine. Per ulteriori informazioni, consulta [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md).
**Assegnare riquadri di delimitazione a un'immagine**
1. Ottenere la riga get JSON per l'immagine esistente, utilizzando `ListDatasetEntries`. Per il campo `source-ref`, specificare la posizione dell'immagine a cui assegnare l'etichetta a livello di immagine. Per ulteriori informazioni, consulta [Elencare le voci del set di dati (SDK)](md-listing-dataset-entries-sdk.md).
1. Aggiornare la riga JSON restituita nel passaggio precedente utilizzando le informazioni disponibili in [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md).
1. Chiamare `UpdateDatasetEntries` per aggiornare l'immagine. Per ulteriori informazioni, consulta [Aggiungere altre immagini a un set di dati](md-add-images.md).
# Debugging set di dati
Durante la creazione del set di dati possono verificarsi due tipi di errori: errori *terminali* e *non terminali*. Gli errori terminali possono impedire la creazione o l'aggiornamento del set di dati. Gli errori non terminali non impediscono la creazione o l'aggiornamento del set di dati.
**Topics**
+ [Eseguire il debug degli errori dei set di dati dei terminali](debugging-datasets-terminal-errors.md)
+ [Debug degli errori dei set di dati non terminali](debugging-datasets-non-terminal-errors.md)
# Eseguire il debug degli errori dei set di dati dei terminali
Esistono due tipi di errori terminali: errori di file che impediscono la creazione del set di dati e quelli di contenuto che Amazon Rekognition Custom Labels rimuove dal set di dati. La creazione del set di dati non riesce se ci sono troppi errori di contenuto.
**Topics**
+ [Errori dei file terminali](#debugging-datasets-terminal-file-errors)
+ [Errori nel contenuto terminale](#debugging-datasets-terminal-content-errors)
## Errori dei file terminali
Di seguito, sono riportati gli errori di file. È possibile ottenere informazioni sugli errori dei file chiamando `DescribeDataset` e controllando i campi `Status` e `StatusMessage`. Per il codice di esempio, consulta [Descrizione di un set di dati (SDK)](md-describing-dataset-sdk.md).
+ [ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT](#md-error-status-ERROR_MANIFEST_INACCESSIBLE_OR_UNSUPPORTED_FORMAT)
+ [ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE](#md-error-status-ERROR_MANIFEST_SIZE_TOO_LARGE).
+ [ERROR\$1MANIFEST\$1ROWS\$1EXCEEDS\$1MAXIMUM](#md-error-status-ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM)
+ [ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET](#md-error-status-ERROR_INVALID_PERMISSIONS_MANIFEST_S3_BUCKET)
+ [ERROR\$1TOO\$1MANY\$1RECORDS\$1IN\$1ERROR](#md-error-status-ERROR_TOO_MANY_RECORDS_IN_ERROR)
+ [ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS](#md-error-status-ERROR_MANIFEST_TOO_MANY_LABELS)
+ [ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1DISTRIBUTE](#md-error-status-ERROR_INSUFFICIENT_IMAGES_PER_LABEL_FOR_DISTRIBUTE)
### ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT
#### Messaggio di errore
L'estensione o il contenuto del file manifest non sono validi.
Il file manifest di addestramento o test non ha un'estensione di file o il suo contenuto non è valido.
**Per correggere l'errore *ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT***
+ Verificare le seguenti possibili cause nei file manifest di addestramento e test.
+ Nei file manifest manca un’estensione file. Per convenzione l'estensione del file è `.manifest`.
+ Non è stato possibile trovare il bucket o la chiave Amazon S3 per il file manifest.
### ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE
#### Messaggio di errore
Le dimensioni del file manifest superano le dimensioni massime supportate.
La dimensione del file manifest di addestramento o test (in byte) è troppo grande. Per ulteriori informazioni, consulta [Linee guida e quote in etichette personalizzate Amazon Rekognition](limits.md). Un file manifest può contenere meno del numero massimo di righe JSON e superare la dimensione massima del file.
Non si può utilizzare la console Amazon Rekognition Custom Labels per correggere l'errore *Le dimensioni del file manifest superano le dimensioni massime supportate*.
**Per correggere l'errore *ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE***
1. Verificare quali dei manifest di addestramento e test superano la dimensione massima del file.
1. Ridurre il numero di righe JSON troppo grandi nei file manifest. Per ulteriori informazioni, consulta [Creazione di un file manifesto](md-create-manifest-file.md).
### ERROR\$1MANIFEST\$1ROWS\$1EXCEEDS\$1MAXIMUM
#### Messaggio di errore
Il file manifest contiene troppe righe.
#### Ulteriori informazioni
Il numero di righe JSON (numero di immagini) nel file manifest è superiore al limite consentito. Il limite è diverso per i modelli a livello di immagine e per i modelli di localizzazione degli oggetti. Per ulteriori informazioni, consulta [Linee guida e quote in etichette personalizzate Amazon Rekognition](limits.md).
Gli errori di riga JSON vengono convalidati affinché il numero di righe JSON non raggiunga il limite `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`.
Non si può utilizzare la console Amazon Rekognition Custom Labels per correggere errori `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`.
**Per correggere `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`**
+ Ridurre il numero di righe JSON nel manifest. Per ulteriori informazioni, consulta [Creazione di un file manifesto](md-create-manifest-file.md).
### ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET
#### Messaggio di errore
Autorizzazioni non corrette del bucket S3.
Amazon Rekognition Custom Labels non dispone delle autorizzazioni per uno o più bucket contenenti i file manifest di addestramento e test.
Non si può utilizzare la console Amazon Rekognition Custom Labels per correggere questo errore.
**Per correggere l'errore *ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET***
+ Controllare le autorizzazioni per i bucket contenenti i manifest di addestramento e test. Per ulteriori informazioni, consulta [Passaggio 2: Configurare le autorizzazioni della console di Amazon Rekognition Custom Labels](su-console-policy.md).
### ERROR\$1TOO\$1MANY\$1RECORDS\$1IN\$1ERROR
#### Messaggio di errore
Il file manifest contiene troppi errori terminali.
**Per correggere `ERROR_TOO_MANY_RECORDS_IN_ERROR`**
+ Ridurre il numero di righe JSON (immagini) con errori di contenuto del terminale. Per ulteriori informazioni, consulta [Errori di contenuti del manifest terminale](tm-debugging-aggregate-errors.md).
Non si può utilizzare la console Amazon Rekognition Custom Labels per correggere questo errore.
### ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS
#### Messaggio di errore
Il file manifest contiene troppe etichette.
##### Ulteriori informazioni
Il numero di etichette univoche nel manifest (set di dati) è superiore al limite consentito. Se il set di dati di addestramento viene suddiviso per creare un set di dati di test, il numero di etichette viene determinato dopo la suddivisione.
**Per correggere ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS (Console)**
+ Rimuovere le etichette dal set di dati. Per ulteriori informazioni, consulta [Gestione etichette](md-labels.md). Le etichette vengono rimosse automaticamente dalle immagini e dai riquadri di delimitazione del set di dati
**Correggere ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS (JSON Line)**
+ Manifest con righe JSON a livello di immagine: se l'immagine ha una singola etichetta, rimuovere le righe JSON per quelle che utilizzano l'etichetta desiderata. Se la riga JSON contiene più etichette, rimuovere solo l'oggetto JSON per l'etichetta desiderata. Per ulteriori informazioni, consulta [Aggiungere più etichette a livello di immagine a un'immagine](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels).
Manifest con la posizione dell'oggetto nelle righe JSON: eliminare il riquadro di delimitazione e le informazioni sull'etichetta associata che si desidera rimuovere. Eseguire questa operazione per ogni riga JSON che contiene l'etichetta desiderata. È necessario rimuovere l'etichetta dalla array `class-map` e dagli oggetti corrispondenti nell'array `objects` e `annotations`. Per ulteriori informazioni, consulta [Localizzazione di oggetti nei file manifest](md-create-manifest-file-object-detection.md).
### ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1DISTRIBUTE
#### Messaggio di errore
Il file manifest non contiene abbastanza immagini etichettate per distribuire il set di dati.
La distribuzione dei set di dati avviene quando Amazon Rekognition Custom Labels divide un set di dati di addestramento per creare un set di dati di test. Si può anche dividere un set di dati chiamando l'API `DistributeDatasetEntries`.
**Correggere l'errore *ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS***
+ Aggiungere altre immagini etichettate al set di dati di addestramento
## Errori nel contenuto terminale
Di seguito, sono riportati gli errori relativi al contenuto terminale. Durante la creazione del set di dati, le immagini che presentano errori di contenuto del terminale vengono rimosse dal set di dati. Il set di dati può ancora essere utilizzato per l’addestramento. Se ci sono troppi errori di contenuto, fallisce. dataset/update Gli errori di contenuto del terminale relativi alle operazioni del set di dati non vengono visualizzati nella console o restituiti da `DescribeDataset` o altre API. Se si nota che nei set di dati mancano immagini o annotazioni, controllare i file manifest del set di dati per i seguenti problemi:
+ La lunghezza di una riga JSON è troppo lunga. La lunghezza massima è 100.000 caratteri.
+ Il valore `source-ref` non è presente in una riga JSON.
+ Il formato di un valore `source-ref` in una riga JSON non è valido.
+ Il contenuto di una riga JSON non è valido.
+ Il valore di un campo `source-ref` appare più di una volta. Si può fare riferimento a un'immagine solo una volta in un set di dati.
Per informazioni sui campi `source-ref`, consultare [Creazione di un file manifesto](md-create-manifest-file.md).
# Debug degli errori dei set di dati non terminali
Di seguito sono riportati gli errori non terminali che possono verificarsi durante la creazione o l'aggiornamento del set di dati. Questi errori possono invalidare un'intera riga JSON o invalidare le annotazioni all'interno di una riga JSON. Se una riga JSON presenta un errore, non viene utilizzata per l'addestramento. Se un'annotazione all'interno di una riga JSON presenta un errore, viene comunque utilizzata per l'addestramento, ma senza l'annotazione interrotta. Per ulteriori informazioni su righe JSON, consultare [Creazione di un file manifesto](md-create-manifest-file.md).
Si può accedere agli errori non terminali dalla console e chiamando l'API `ListDatasetEntries`. Per ulteriori informazioni, consulta [Elencare le voci del set di dati (SDK)](md-listing-dataset-entries-sdk.md).
Durante l’addestramento vengono inoltre restituiti i seguenti errori. Si consiglia di correggere questi errori prima di addestrare il modello. Per ulteriori informazioni, consulta [Errori di convalida della riga JSON non terminale](tm-debugging-json-line-errors.md).
+ [ERROR\$1NO\$1LABEL\$1ATTRIBUTES](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_LABEL_ATTRIBUTES)
+ [ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1FORMAT](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_ATTRIBUTE_FORMAT)
+ [ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1METADATA\$1FORMAT](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_ATTRIBUTE_METADATA_FORMAT)
+ [ERROR\$1NO\$1VALID\$1LABEL\$1ATTRIBUTES](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_VALID_LABEL_ATTRIBUTES)
+ [ERROR\$1INVALID\$1BOUNDING\$1BOX](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_BOUNDING_BOX)
+ [ERROR\$1INVALID\$1IMAGE\$1DIMENSION](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_IMAGE_DIMENSION)
+ [ERROR\$1BOUNDING\$1BOX\$1TOO\$1SMALL](tm-debugging-json-line-errors.md#tm-error-ERROR_BOUNDING_BOX_TOO_SMALL)
+ [ERROR\$1NO\$1VALID\$1ANNOTATIONS](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_VALID_ANNOTATIONS)
+ [ERROR\$1MISSING\$1BOUNDING\$1BOX\$1CONFIDENCE](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_BOUNDING_BOX_CONFIDENCE)
+ [ERROR\$1MISSING\$1CLASS\$1MAP\$1ID](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_CLASS_MAP_ID)
+ [ERROR\$1TOO\$1MANY\$1BOUNDING\$1BOXES](tm-debugging-json-line-errors.md#tm-error-ERROR_TOO_MANY_BOUNDING_BOXES)
+ [ERROR\$1UNSUPPORTED\$1USE\$1CASE\$1TYPE](tm-debugging-json-line-errors.md#tm-error-ERROR_UNSUPPORTED_USE_CASE_TYPE)
+ [ERROR\$1INVALID\$1LABEL\$1NAME\$1LENGTH](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_NAME_LENGTH)
## Accesso agli errori non terminali
Si può usare la console per scoprire quali immagini in un set di dati presentano errori non terminali. È possibile chiamare l'API `ListDatasetEntries` per ricevere i messaggi di errore. Per ulteriori informazioni, consulta [Elencare le voci del set di dati (SDK)](md-listing-dataset-entries-sdk.md).
**Per accedere agli errori non terminali (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 da usare. Viene visualizzata la pagina dei dettagli del progetto.
1. Se si vogliono visualizzare gli errori non terminali nel tuo set di dati di addestramento, scegliere la scheda **Addestramento**. Altrimenti scegliere la scheda **Test** per visualizzare gli errori non terminali nel set di dati di test.
1. Nella sezione **Etichette** della galleria del set di dati, scegliere **Errori**. La galleria del set di dati viene filtrata per mostrare solo le immagini con errori.
1. Scegliere **Errore** sotto un'immagine per vedere il codice di errore. Usare le informazioni disponibili in [Errori di convalida della riga JSON non terminale](tm-debugging-json-line-errors.md) per correggere l'errore.
![\[Finestra di dialogo di errore che mostra «ERROR_UNSUPPORTED_USE_CASE_TYPE» e «ERROR_NO_VALID_LABEL_ATTRIBUTES» in «Dataset record errors».\]](http://docs.aws.amazon.com/it_it/rekognition/latest/customlabels-dg/images/dataset-non-terminal-error.jpg)