Analisi delle immagini con una funzione AWS Lambda - Rekognition

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

Analisi delle immagini con una funzione AWS Lambda

AWS Lambda è un servizio di elaborazione che consente di eseguire codice senza fornire o gestire server. Ad esempio, puoi analizzare le immagini inviate da un'applicazione mobile senza dover creare un server come host per il codice dell'applicazione. Le seguenti istruzioni mostrano come creare una funzione Lambda in Python che chiama. DetectCustomLabels La funzione analizza un'immagine fornita e restituisce un elenco di etichette presenti nell'immagine. Le istruzioni includono un esempio di codice Python che mostra come chiamare la funzione Lambda con un'immagine in un bucket Amazon S3 o un'immagine fornita da un computer locale.

Fase 1: Creare una AWS Lambda funzione (console)

In questo passaggio, si crea una AWS funzione vuota e un ruolo di IAM esecuzione che consente alla funzione di richiamare l'DetectCustomLabelsoperazione. Permette inoltre l'accesso al bucket Amazon S3 che archivia le immagini per l'analisi. È inoltre possibile specificare variabili di ambiente per quanto segue:

  • Il modello Amazon Rekognition Custom Labels che desideri venga utilizzato dalla funzione Lambda.

  • Il limite di affidabilità che desideri venga utilizzato dal modello.

Successivamente aggiungi il codice sorgente e, facoltativamente, un livello alla funzione Lambda.

Per creare una AWS Lambda funzione (console)
  1. Accedi a AWS Management Console e apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

  2. Scegli Crea funzione. Per ulteriori informazioni, consulta Creare una funzione Lambda con la console.

  3. Scegli le opzioni seguenti.

    • Scegli Crea da zero.

    • Inserisci un valore Nome per la funzione.

    • In Runtime, scegli Python 3.10.

  4. Scegli Crea funzione per creare la funzione AWS Lambda .

  5. Nella pagina della funzione, scegli la scheda Configurazione.

  6. Nella sezione Variabili di ambiente, scegli Modifica.

  7. Aggiungi le seguenti variabili di ambiente. Per ogni variabile, scegli Aggiungi variabile di ambiente, quindi immetti la chiave e il valore della variabile.

    Chiave Valore

    MODEL_ARN

    L'Amazon Resource Name (ARN) del modello che desideri venga utilizzato dalla funzione Lambda. Puoi ottenere il modello ARN dalla scheda Use Model della pagina dei dettagli del modello nella console Amazon Rekognition Custom Labels.

    CONFIDENCE

    Il valore minimo (0—100) per l'affidabilità del modello nella previsione di un'etichetta. La funzione Lambda non restituisce etichette con valori di affidabilità inferiori a questo valore.

  8. Scegli Salva per salvare le variabili di ambiente.

  9. Nel riquadro Autorizzazioni, in Nome ruolo, scegli il ruolo di esecuzione per aprire il ruolo nella console. IAM

  10. Nella scheda Autorizzazioni, scegli Aggiungi autorizzazioni, poi Crea policy inline.

  11. Scegli JSONe sostituisci la politica esistente con la seguente politica.

    { "Version": "2012-10-17", "Statement": [ { "Action": "rekognition:DetectCustomLabels", "Resource": "*", "Effect": "Allow", "Sid": "DetectCustomLabels" } ] }
  12. Scegli Next (Successivo).

  13. Nei dettagli della politica, inserisci un nome per la politica, ad esempio DetectCustomLabels-access.

  14. Scegli Create Policy (Crea policy).

  15. Se stai archiviando immagini per l'analisi in un bucket Amazon S3, ripeti i passaggi da 10 a 14.

    1. Per il passaggio 11, utilizza la seguente policy. Replace (Sostituisci) bucket/folder path con il bucket Amazon S3 e il percorso della cartella verso le immagini che desideri analizzare.

      { "Version": "2012-10-17", "Statement": [ { "Sid": "S3Access", "Effect": "Allow", "Action": "s3:GetObject", "Resource": "arn:aws:s3:::bucket/folder path/*" } ] }
    2. Per il passaggio 13, scegli un nome di policy diverso, ad esempio S3Bucket-access.

Fase 2: (facoltativa) Creazione di un livello (console)

Per eseguire questo esempio, non è necessario eseguire questa operazione. L'DetectCustomLabelsoperazione è inclusa nell'ambiente Lambda Python predefinito come parte di for AWS SDK Python (Boto3). Se altre parti della tua funzione Lambda necessitano di aggiornamenti recenti del AWS servizio che non si trovano nell'ambiente Lambda Python predefinito, esegui questo passaggio per aggiungere l'ultima versione di Boto3 SDK come livello alla tua funzione.

Innanzitutto, create un archivio di file.zip che contiene Boto3. SDK Quindi crea un livello e aggiungi l'archivio di file .zip al livello. Per ulteriori informazioni, consulta Utilizzo dei livelli con la funzione Lambda.

Creare e aggiungere un livello (console)
  1. Apri un prompt di comandi e inserisci il comando seguente.

    pip install boto3 --target python/. zip boto3-layer.zip -r python/
  2. Annota il nome del file .zip (boto3-layer.zip). Questo valore sarà necessario nel passaggio 6 di questa procedura.

  3. Apri la console all' AWS Lambda indirizzo. https://console.aws.amazon.com/lambda/

  4. Nel riquadro di navigazione scegli Layers (Livelli).

  5. Scegli Create layer (Crea livello).

  6. Immetti i valori per Nome (Nome) e Description (Descrizione).

  7. Seleziona Carica file .zip, quindi scegli Carica.

  8. Nella finestra di dialogo, scegli l'archivio di file .zip (boto3-layer.zip) creato nel passaggio 1 di questa procedura.

  9. Per runtime compatibili, scegli Python 3.9.

  10. Scegli Crea per creare lo strato.

  11. Scegli l'icona del menu del pannello di navigazione.

  12. Nel riquadro di navigazione, seleziona Funzioni.

  13. Nell'elenco delle risorse, scegli la funzione in cui è stata creata Fase 1: Creare una AWS Lambda funzione (console).

  14. Scegli la scheda Codice.

  15. Nella sezione Livelli, scegli Aggiungi un livello.

  16. Scegliete Livelli personalizzati.

  17. In Livelli personalizzati, scegli il nome del livello che hai inserito nel passaggio 6.

  18. In Versione scegli la versione del livello, che dovrebbe essere 1.

  19. Scegli Aggiungi.

Passaggio 3: Aggiungere codice Python (console)

In questo passaggio, aggiungi codice Python alla tua funzione Lambda utilizzando l'editor di codice della console Lambda. Il codice analizza un'immagine fornita con DetectCustomLabels e restituisce un elenco di etichette presenti nell'immagine. L'immagine fornita può essere archiviata in un bucket Amazon S3 o fornita come byte di immagine con codifica byte64.

Per aggiungere codice Python (console)
  1. Se non ti trovi nella console Lambda, esegui quanto segue:

    1. Apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

    2. Apri la funzione Lambda che hai creato in Fase 1: Creare una AWS Lambda funzione (console).

  2. Scegli la scheda Codice.

  3. In Codice sorgente, sostituisci il codice in lambda_function.py con quanto segue:

    # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose An AWS lambda function that analyzes images with an the Amazon Rekognition Custom Labels model. """ import json import base64 from os import environ import logging import boto3 from botocore.exceptions import ClientError # Set up logging. logger = logging.getLogger(__name__) # Get the model ARN and confidence. model_arn = environ['MODEL_ARN'] min_confidence = int(environ.get('CONFIDENCE', 50)) # Get the boto3 client. rek_client = boto3.client('rekognition') def lambda_handler(event, context): """ Lambda handler function param: event: The event object for the Lambda function. param: context: The context object for the lambda function. return: The labels found in the image passed in the event object. """ try: # Determine image source. if 'image' in event: # Decode the image image_bytes = event['image'].encode('utf-8') img_b64decoded = base64.b64decode(image_bytes) image = {'Bytes': img_b64decoded} elif 'S3Object' in event: image = {'S3Object': {'Bucket': event['S3Object']['Bucket'], 'Name': event['S3Object']['Name']} } else: raise ValueError( 'Invalid source. Only image base 64 encoded image bytes or S3Object are supported.') # Analyze the image. response = rek_client.detect_custom_labels(Image=image, MinConfidence=min_confidence, ProjectVersionArn=model_arn) # Get the custom labels labels = response['CustomLabels'] lambda_response = { "statusCode": 200, "body": json.dumps(labels) } except ClientError as err: error_message = f"Couldn't analyze image. " + \ err.response['Error']['Message'] lambda_response = { 'statusCode': 400, 'body': { "Error": err.response['Error']['Code'], "ErrorMessage": error_message } } logger.error("Error function %s: %s", context.invoked_function_arn, error_message) except ValueError as val_error: lambda_response = { 'statusCode': 400, 'body': { "Error": "ValueError", "ErrorMessage": format(val_error) } } logger.error("Error function %s: %s", context.invoked_function_arn, format(val_error)) return lambda_response
  4. Per distribuire il codice della funzione Lambda, scegli Distribuisci.

Passaggio 4: Prova la funzione Lambda

In questo passaggio usa il codice Python sul tuo computer per trasferire un'immagine locale, o un'immagine in un bucket Amazon S3, alla tua funzione Lambda. Le immagini trasmesse da un computer locale devono avere dimensioni inferiori a 6291456 byte. Se le tue immagini sono più grandi, carica le immagini in un bucket Amazon S3 e chiama lo script con il percorso Amazon S3 per l'immagine. Per ulteriori informazioni su come caricare file su un bucket Amazon S3, consulta Caricamento degli oggetti.

Assicurati di eseguire il codice nella stessa AWS regione in cui hai creato la funzione Lambda. Puoi visualizzare la AWS regione per la tua funzione Lambda nella barra di navigazione della pagina dei dettagli della funzione nella console Lambda.

Se la AWS Lambda funzione restituisce un errore di timeout, estendi il periodo di timeout per la funzione Lambda. Per ulteriori informazioni, vedi Configurazione del timeout della funzione (console).

Per ulteriori informazioni sull'invocazione di una funzione Lambda dal codice, consulta AWS Lambda Invoking Functions.

Provare la funzione Lambda
  1. Assicurati di disporre dell’autorizzazione lambda:InvokeFunction. Puoi usare la seguente policy.

    { "Version": "2012-10-17", "Statement": [ { "Sid": "InvokeLambda", "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "ARN for lambda function" } ] }

    Puoi ottenere la funzione ARN per la tua funzione Lambda dalla panoramica delle funzioni nella console Lambda.

    Per fornire l'accesso, aggiungi autorizzazioni ai tuoi utenti, gruppi o ruoli:

  2. Installa e configura AWS SDK per Python. Per ulteriori informazioni, consulta Passaggio 4: configura il AWS CLI e AWS SDKs.

  3. Avvia il modello specificato nel passaggio 7 di Fase 1: Creare una AWS Lambda funzione (console).

  4. Salva il seguente codice in un file denominato client.py.

    # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Test code for running the Amazon Rekognition Custom Labels Lambda function example code. """ import argparse import logging import base64 import json import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) def analyze_image(function_name, image): """Analyzes an image with an AWS Lambda function. :param image: The image that you want to analyze. :return The status and classification result for the image analysis. """ lambda_client = boto3.client('lambda') lambda_payload = {} if image.startswith('s3://'): logger.info("Analyzing image from S3 bucket: %s", image) bucket, key = image.replace("s3://", "").split("/", 1) s3_object = { 'Bucket': bucket, 'Name': key } lambda_payload = {"S3Object": s3_object} # Call the lambda function with the image. else: with open(image, 'rb') as image_file: logger.info("Analyzing local image image: %s ", image) image_bytes = image_file.read() data = base64.b64encode(image_bytes).decode("utf8") lambda_payload = {"image": data} response = lambda_client.invoke(FunctionName=function_name, Payload=json.dumps(lambda_payload)) return json.loads(response['Payload'].read().decode()) def add_arguments(parser): """ Adds command line arguments to the parser. :param parser: The command line parser. """ parser.add_argument( "function", help="The name of the AWS Lambda function that you want " \ "to use to analyze the image.") parser.add_argument( "image", help="The local image that you want to analyze.") def main(): """ Entrypoint for script. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") # Get command line arguments. parser = argparse.ArgumentParser(usage=argparse.SUPPRESS) add_arguments(parser) args = parser.parse_args() # Get analysis results. result = analyze_image(args.function, args.image) status = result['statusCode'] if status == 200: labels = result['body'] labels = json.loads(labels) print(f"There are {len(labels)} labels in the image.") for custom_label in labels: confidence = int(round(custom_label['Confidence'], 0)) print( f"Label: {custom_label['Name']}: Confidence: {confidence}%") else: print(f"Error: {result['statusCode']}") print(f"Message: {result['body']}") except ClientError as error: logging.error(error) print(error) if __name__ == "__main__": main()
  5. Eseguire il codice. Per l'argomento della riga di comando, fornisci il nome della funzione Lambda e l'immagine che desideri analizzare. È possibile fornire un percorso per un'immagine locale o il percorso S3 per un'immagine archiviata in un bucket Amazon S3. Per esempio:

    python client.py function_name s3://bucket/path/image.jpg

    Se l'immagine è archiviata in un bucket Amazon S3, assicurati che sia lo stesso bucket specificato nel passaggio 15 di Fase 1: Creare una AWS Lambda funzione (console).

    In caso di esito positivo, l'output è un elenco di etichette trovate nell'immagine. Se non viene restituita alcuna etichetta, valuta la possibilità di ridurre il valore di affidabilità impostato nel passaggio 7 di Fase 1: Creare una AWS Lambda funzione (console).

  6. Se hai completato il processo con la funzione Lambda e il modello non viene utilizzato da altre applicazioni, interrompi il modello. Ricordati di avviare il modello la prossima volta che desideri utilizzare la funzione Lambda.