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à. # 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).