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à. # Utilizzo di funzioni Lambda di pre-annotazione e post-annotazione Utilizza questi argomenti per scoprire la sintassi delle richieste inviate alle funzioni Lambda di pre-annotazione e post-annotazione e la sintassi di risposta richiesta, utilizzata da Ground Truth nei flussi di lavoro di etichettatura personalizzati. **Topics** + [Lambda di pre-annotazione](#sms-custom-templates-step3-prelambda) + [Lambda di post-annotazione](#sms-custom-templates-step3-postlambda) ## Lambda di pre-annotazione Prima che un’attività di etichettatura venga inviata al worker, viene invocata una funzione Lambda di pre-annotazione opzionale. Ground Truth invia alla funzione Lambda una richiesta in formato JSON per fornire informazioni sul processo di etichettatura e sull’oggetto di dati. Di seguito sono riportati 2 esempi di richieste in formato JSON. ------ #### [ Data object identified with "source-ref" ] ``` { "version": "2018-10-16", "labelingJobArn": {{}} "dataObject" : { "source-ref": {{}} } } ``` ------ #### [ Data object identified with "source" ] ``` { "version": "2018-10-16", "labelingJobArn": {{}} "dataObject" : { "source": {{}} } } ``` ------ L’elenco seguente contiene gli schemi di richiesta di pre-annotazione. Di seguito è riportata una descrizione di ciascun parametro. + `version` (stringa): questo è un numero di versione usato internamente da Ground Truth. + `labelingJobArn` (stringa): questo è l'Amazon Resource Name, o ARN, del proprio processo di etichettatura. Questo ARN può essere utilizzato come riferimento al processo di etichettatura quando si utilizzano operazioni dell’API Ground Truth come `DescribeLabelingJob`. + `dataObject` (oggetto JSON): la chiave contiene un'unica riga JSON, dal file manifest di input o inviata da Amazon SNS. Gli oggetti riga JSON nel tuo manifest possono essere di dimensioni fino a 100 KB e contenere un'ampia gamma di dati. Per un processo di annotazione di immagini molto semplice, il JSON `dataObject` può contenere solo una chiave `source-ref`, che identifica l'immagine da annotare. Se l'oggetto dati (ad esempio, una riga di testo) è incluso direttamente nel file manifest di input, l'oggetto dati viene identificato con `source`. Se si crea un processo di verifica o regolazione, questa riga può contenere i dati dell'etichetta e i metadati del precedente processo di etichettatura. I seguenti esempi a schede mostrano esempi di una richiesta di pre-annotazione. Ogni parametro di queste richieste di esempio è spiegato sotto la tabella a schede. ------ #### [ Data object identified with "source-ref" ] ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker:us-west-2:111122223333:labeling-job/" "dataObject" : { "source-ref": "s3://input-data-bucket/data-object-file-name" } } ``` ------ #### [ Data object identified with "source" ] ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker::111122223333:labeling-job/" "dataObject" : { "source": "Sue purchased 10 shares of the stock on April 10th, 2020" } } ``` ------ In cambio, Ground Truth richiede una risposta formattata come la seguente: **Example di dati di restituzione previsti** ``` { "taskInput": {{}}, "isHumanAnnotationRequired": {{}} # Optional } ``` Nell'esempio precedente, `` deve contenere *tutti* i dati richiesti dal modello di attività del worker personalizzato. Se stai eseguendo un'attività del riquadro di delimitazione in cui le istruzioni rimangono sempre le stesse, può essere semplicemente la risorsa HTTP(S) o Amazon S3 per il file di immagine. Se si tratta di un'attività di analisi del sentiment e oggetti diversi possono avere scelte diverse, sarà il riferimento dell'oggetto come una stringa e le scelte come una matrice di stringhe. **Implicazioni di `isHumanAnnotationRequired`** Questo valore è facoltativo perché viene utilizzato `true` come valore predefinito. Il caso d'uso principale per l'impostazione esplicita è quando desideri escludere questo oggetto dati dall'etichettatura eseguita dai worker. Se hai una combinazione di oggetti del manifest, in cui alcuni richiedono l'annotazione umana e alcuni non la richiedono, puoi includere un valore `isHumanAnnotationRequired` in ogni oggetto dati. È possibile aggiungere una logica alla propria Lambda di pre-annotazione per determinare in modo dinamico se un oggetto richiede l'annotazione e impostare questo valore booleano di conseguenza. ### Esempi di funzioni Lambda di pre-annotazione La seguente funzione Lambda di pre-annotazione di base accede all’oggetto JSON in `dataObject` dalla richiesta iniziale e lo restituisce nel parametro `taskInput`. ``` import json def lambda_handler(event, context): return { "taskInput": event['dataObject'] } ``` Supponendo che il file manifest di input utilizzi `"source-ref"` per identificare gli oggetti dati, il modello di attività del worker utilizzato nello stesso processo di etichettatura di questa Lambda di pre-annotazione deve includere un elemento Liquid come il seguente da importare `dataObject`: ``` {{ task.input.source-ref | grant_read_access }} ``` Se il file manifest di input ha utilizzato `source` per identificare l'oggetto dati, il modello di attività di elaborazione può importare `dataObject` con quanto segue: ``` {{ task.input.source }} ``` Il seguente esempio di pre-annotazione Lambda include una logica per identificare la chiave utilizzata in `dataObject` e per indicare l'oggetto dati utilizzando `taskObject` nell'istruzione return di Lambda. ``` import json def lambda_handler(event, context): # Event received print("Received event: " + json.dumps(event, indent=2)) # Get source if specified source = event['dataObject']['source'] if "source" in event['dataObject'] else None # Get source-ref if specified source_ref = event['dataObject']['source-ref'] if "source-ref" in event['dataObject'] else None # if source field present, take that otherwise take source-ref task_object = source if source is not None else source_ref # Build response object output = { "taskInput": { "taskObject": task_object }, "humanAnnotationRequired": "true" } print(output) # If neither source nor source-ref specified, mark the annotation failed if task_object is None: print(" Failed to pre-process {} !".format(event["labelingJobArn"])) output["humanAnnotationRequired"] = "false" return output ``` ## Lambda di post-annotazione Quando tutti i worker hanno annotato l'oggetto dati o quando è stato raggiunto [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HumanLoopConfig.html#SageMaker-Type-HumanLoopConfig-TaskAvailabilityLifetimeInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HumanLoopConfig.html#SageMaker-Type-HumanLoopConfig-TaskAvailabilityLifetimeInSeconds), a seconda di ciò che avviene prima, Ground Truth invia tali annotazioni al proprio Lambda di post-annotazione. Questa Lambda viene generalmente utilizzata per [Consolidamento delle annotazioni](sms-annotation-consolidation.md). **Nota** [Per vedere un esempio di funzione Lambda post-consolidamento, consulta [annotation\_consolidation\_lambda.py](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe/blob/master/aws_sagemaker_ground_truth_sample_lambda/annotation_consolidation_lambda.py) nel repository -recipe. aws-sagemaker-ground-truth](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe) GitHub Il blocco di codice seguente contiene lo schema di richiesta di post-annotazione. Ogni parametro è descritto nell'elenco puntato seguente. ``` { "version": "2018-10-16", "labelingJobArn": {{}}, "labelCategories": [{{}}], "labelAttributeName": {{}}, "roleArn" : {{}}, "payload": { "s3Uri": {{}} } } ``` + `version` (stringa): un numero di versione usato internamente da Ground Truth. + `labelingJobArn` (stringa): l'Amazon Resource Name, o ARN, del proprio processo di etichettatura. Questo ARN può essere utilizzato come riferimento al processo di etichettatura quando si utilizzano operazioni dell'API Ground Truth come `DescribeLabelingJob`. + `labelCategories` (elenco di stringhe): include le categorie di etichette e altri attributi specificati nella console o inclusi nel file di configurazione delle categorie di etichette. + `labelAttributeName` (stringa): il nome del processo di etichettatura o il nome dell'attributo dell'etichetta specificato quando si crea il processo di etichettatura. + `roleArn` (stringa): il nome della risorsa Amazon (ARN) del ruolo di esecuzione IAM specificato quando si crea il processo di etichettatura. + `payload` (oggetto JSON): un JSON che include una chiave `s3Uri`, che identifica la posizione dei dati di annotazione per quell'oggetto dati in Amazon S3. Il secondo blocco di codice riportato di seguito mostra un esempio di questo file di annotazioni. Il blocco di codice seguente contiene un esempio di richiesta post-annotazione. Ogni parametro in questo esempio è spiegato sotto il blocco di codice. **Example di una richiesta Lambda post-annotazione** ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker:us-west-2:111122223333:labeling-job/labeling-job-name", "labelCategories": ["Ex Category1","Ex Category2", "Ex Category3"], "labelAttributeName": "labeling-job-attribute-name", "roleArn" : "arn:aws:iam::111122223333:role/role-name", "payload": { "s3Uri": "s3://amzn-s3-demo-bucket/annotations.json" } } ``` **Nota** Se nessun worker utilizza l'oggetto dati ed è stato raggiunto `TaskAvailabilityLifetimeInSeconds`, l'oggetto dati verrà contrassegnato come non riuscito e non verrà incluso come parte della richiesta Lambda post-annotazione. Il seguente blocco di codice contiene lo schema di payload. Questo è il file indicato dal parametro `s3Uri` nell'oggetto JSON `payload` della richiesta Lambda post-annotazione. Ad esempio, se il blocco di codice precedente è la richiesta Lambda post-annotazione, il seguente file di annotazione si trova in `s3://amzn-s3-demo-bucket/annotations.json`. Ogni parametro è descritto nell'elenco puntato seguente. **Example di un file di annotazioni** ``` [ { "datasetObjectId": {{}}, "dataObject": { "s3Uri": {{}}, "content": {{}} }, "annotations": [{ "workerId": {{}}, "annotationData": { "content": {{}}, "s3Uri": {{}} } }] } ] ``` + `datasetObjectId` (stringa): identifica un ID univoco che Ground Truth assegna a ciascun oggetto dati inviato al processo di etichettatura. + `dataObject` (oggetto JSON): l'oggetto dati che è stato etichettato. Se l'oggetto dati è incluso nel file manifesto di input e identificato utilizzando la chiave `source` (ad esempio una stringa), `dataObject` include una chiave `content` che identifica l'oggetto dati. Altrimenti, la posizione dell'oggetto dati (ad esempio, un link o un URI S3) viene identificata con `s3Uri`. + `annotations` (elenco di oggetti JSON): questo elenco contiene un unico oggetto JSON per ciascuna annotazione inviata dai worker a tale `dataObject`. Un singolo oggetto JSON contiene un `workerId` univoco che può essere utilizzato per identificare il worker che ha inviato l'annotazione. La chiave `annotationData` contiene uno dei seguenti elementi: + `content` (stringa): contiene i dati di annotazione. + `s3Uri` (stringa): contiene un URI S3 che identifica la posizione dei dati di annotazione. La tabella seguente contiene esempi del contenuto che è possibile trovare nel payload per diversi tipi di annotazioni. ------ #### [ Named Entity Recognition Payload ] ``` [ { "datasetObjectId": "1", "dataObject": { "content": "Sift 3 cups of flour into the bowl." }, "annotations": [ { "workerId": "private.us-west-2.ef7294f850a3d9d1", "annotationData": { "content": "{\"crowd-entity-annotation\":{\"entities\":[{\"endOffset\":4,\"label\":\"verb\",\"startOffset\":0},{\"endOffset\":6,\"label\":\"number\",\"startOffset\":5},{\"endOffset\":20,\"label\":\"object\",\"startOffset\":15},{\"endOffset\":34,\"label\":\"object\",\"startOffset\":30}]}}" } } ] } ] ``` ------ #### [ Semantic Segmentation Payload ] ``` [ { "datasetObjectId": "2", "dataObject": { "s3Uri": "s3://amzn-s3-demo-bucket/gt-input-data/images/bird3.jpg" }, "annotations": [ { "workerId": "private.us-west-2.ab1234c5678a919d0", "annotationData": { "content": "{\"crowd-semantic-segmentation\":{\"inputImageProperties\":{\"height\":2000,\"width\":3020},\"labelMappings\":{\"Bird\":{\"color\":\"#2ca02c\"}},\"labeledImage\":{\"pngImageData\":\"iVBOR...\"}}}" } } ] } ] ``` ------ #### [ Bounding Box Payload ] ``` [ { "datasetObjectId": "0", "dataObject": { "s3Uri": "s3://amzn-s3-demo-bucket/gt-input-data/images/bird1.jpg" }, "annotations": [ { "workerId": "private.us-west-2.ab1234c5678a919d0", "annotationData": { "content": "{\"boundingBox\":{\"boundingBoxes\":[{\"height\":2052,\"label\":\"Bird\",\"left\":583,\"top\":302,\"width\":1375}],\"inputImageProperties\":{\"height\":2497,\"width\":3745}}}" } } ] } ] ``` ------ La funzione Lambda post-annotazione può contenere una logica simile alla seguente per scorrere in loop e accedere a tutte le annotazioni contenute nella richiesta. [Per un esempio completo, consulta [annotation\_consolidation\_lambda.py](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe/blob/master/aws_sagemaker_ground_truth_sample_lambda/annotation_consolidation_lambda.py) nel repository -recipe. aws-sagemaker-ground-truth](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe) GitHub In questo GitHub esempio, è necessario aggiungere la propria logica di consolidamento delle annotazioni. ``` for i in range(len(annotations)): worker_id = annotations[i]["workerId"] annotation_content = annotations[i]['annotationData'].get('content') annotation_s3_uri = annotations[i]['annotationData'].get('s3uri') annotation = annotation_content if annotation_s3_uri is None else s3_client.get_object_from_s3( annotation_s3_uri) annotation_from_single_worker = json.loads(annotation) print("{} Received Annotations from worker [{}] is [{}]" .format(log_prefix, worker_id, annotation_from_single_worker)) ``` **Suggerimento** Quando esegui algoritmi di consolidamento sui dati, puoi utilizzare un servizio di database AWS per archiviare i risultati oppure puoi restituire i risultati elaborati a Ground Truth. I dati restituiti a Ground Truth vengono archiviati in manifesti di annotazione consolidati nel bucket S3 specificato per l'output durante la configurazione del processo di etichettatura. In cambio, Ground Truth richiede una risposta formattata come la seguente: **Example di dati di restituzione previsti** ``` [ { "datasetObjectId": {{}}, "consolidatedAnnotation": { "content": { "{{}}": { {{# ... label content}} } } } }, { "datasetObjectId": {{}}, "consolidatedAnnotation": { "content": { "{{}}": { {{# ... label content}} } } } } . . . ] ``` A questo punto, tutti i dati che stai inviando al bucket S3, tranne `datasetObjectId`, saranno nell'oggetto `content`. Quando restituisci le annotazioni `content`, ciò porta a una voce nel manifesto di output del proprio processo simile alla seguente: **Example di formato etichetta nel manifest di output** ``` { "source-ref"/"source" : "{{}}", "<{{labelAttributeName>}}": { {{# ... label content from you}} }, "{{}}-metadata": { # This will be added by Ground Truth "job_name": {{}}, "type": "groundTruth/custom", "human-annotated": "yes", "creation_date": # Timestamp of when received from Post-labeling Lambda } } ``` A causa della natura potenzialmente complessa di un modello personalizzato e dei dati che raccoglie, Ground Truth non offre un'ulteriore elaborazione dei dati.