Analysieren von Bildern mit einer Funktion AWS Lambda

Melden Sie sich bei der an AWS Management Console und öffnen Sie die AWS Lambda Konsole unter https://console.aws.amazon.com/lambda/.

Wählen Sie Funktion erstellen aus. Weitere Informationen zur Verwendung von Lambda finden Sie unter Erstellen einer Lambda-Funktion mit der Konsole.

Wählen Sie aus den folgenden Optionen.

Wählen Sie Funktion erstellen aus, um die AWS Lambda -Funktion zu erstellen.

Wählen Sie auf der Seite der Funktion den Tab Konfiguration aus.

Wählen Sie im Abschnitt Umgebungsvariablen Bearbeiten aus.

Fügen Sie die folgenden Umgebungsvariablen hinzu. Wählen Sie für jede Variable die Option Umgebungsvariable hinzufügen und geben Sie dann den Variablenschlüssel und den Wert ein.

Wählen Sie Speichern, um die Umgebungsvariablen zu speichern.

Wählen Sie im Bereich Berechtigungen unter Rollenname die Ausführungsrolle aus, um die Rolle in der IAM Konsole zu öffnen.

Wählen Sie auf der Registerkarte Berechtigungen die Optionen Berechtigungen hinzufügen und dann Inline-Richtlinie erstellen aus.

Wählen Sie die bestehende Richtlinie aus JSONund ersetzen Sie sie durch die folgende Richtlinie.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": "rekognition:DetectCustomLabels",
            "Resource": "*",
            "Effect": "Allow",
            "Sid": "DetectCustomLabels"
        }
    ]
}

Wählen Sie Weiter.

Geben Sie unter Richtliniendetails einen Namen für die Richtlinie ein, z. B. DetectCustomLabels-access.

Wählen Sie Create Policy (Richtlinie erstellen) aus.

Wenn Sie Bilder zur Analyse in einem Amazon-S3-Bucket speichern, wiederholen Sie die Schritte 10-14.

1. Verwenden Sie für Schritt 11 die folgende Richtlinie. Ersetzen bucket/folder path mit dem Amazon S3 S3-Bucket und dem Ordnerpfad zu den Bildern, die Sie analysieren möchten.

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Sid": "S3Access",
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::bucket/folder path/*"
           }
       ]
   }

2. Wählen Sie für Schritt 13 einen anderen Richtliniennamen aus, z. B. S3Bucket-access.

Öffnen Sie eine Eingabeaufforderung und geben Sie dann die folgenden Befehle ein.

pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                

Notieren Sie sich den Namen der Zip-Datei (boto3-layer.zip). Sie benötigen ihm im Schritt 6 dieses Vorgangs.

Öffnen Sie die Konsole unter AWS Lambda . https://console.aws.amazon.com/lambda/

Wählen Sie im Navigationsbereich Ebenen aus.

Wählen Sie Ebene erstellen aus.

Geben Sie einen Namen und eine Beschreibung ein.

Wählen Sie Zip-Datei hochladen und dann Upload aus.

Wählen Sie im Dialogfeld das ZIP-Dateiarchiv (boto3-layer.zip) aus, das Sie in Schritt 1 dieses Vorgangs erstellt haben.

Wählen Sie für kompatible Laufzeiten Python 3.9.

Wählen Sie Erstellen, um die Ebene zu erstellen.

Wählen Sie das Menüsymbol im Navigationsbereich.

Wählen Sie im Navigationsbereich Funktionen aus.

Wählen Sie in der Ressourcenliste die Funktion aus, die Sie in Schritt 1: Erstellen Sie eine AWS Lambda Funktion (Konsole) erstellt haben.

Wählen Sie die Registerkarte Code.

Wählen Sie im Bereich Ebenen die Option Ebene hinzufügen aus.

Wählen Sie Benutzerdefinierte Ebenen.

Wählen Sie unter Benutzerdefinierte Ebenen den Namen der Ebene aus, den Sie in Schritt 6 eingegeben haben.

Wählen Sie unter Version die Version der Ebene aus, die 1 sein sollte.

Wählen Sie Hinzufügen aus.

Wenn Sie nicht in der Lambda-Konsole sind, gehen Sie wie folgt vor:

1. Öffnen Sie die AWS Lambda Konsole unter https://console.aws.amazon.com/lambda/.

2. Öffnen Sie die Lambda-Funktion, die Sie in Schritt 1: Erstellen Sie eine AWS Lambda Funktion (Konsole) erstellt haben.

Wählen Sie die Registerkarte Code.

Ersetzen Sie in der Codequelle den Code in lambda_function.py durch den folgenden Code:

# 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

Wählen Sie Implementieren aus, um Ihre Lambda-Funktion bereitzustellen.

Achten Sie darauf, dass Sie die lambda:InvokeFunction-Berechtigung haben. Sie können die folgende Richtlinie verwenden.

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

Sie können die Funktion ARN für Ihre Lambda-Funktion aus der Funktionsübersicht in der Lambda-Konsole abrufen.

Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:

Installieren und konfigurieren Sie AWS SDK für Python. Weitere Informationen finden Sie unter Schritt 4: Richten Sie das ein AWS CLI and AWS SDKs.

Starten Sie das Modell, das Sie in Schritt 7 von Schritt 1: Erstellen Sie eine AWS Lambda Funktion (Konsole) angegeben haben.

Speichern Sie den folgenden Code in eine Datei mit dem Namen 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()

Führen Sie den Code aus. Geben Sie für das Befehlszeilenargument den Namen der Lambda-Funktion und das Bild an, das Sie analysieren möchten. Sie können einen Pfad zu einem lokalen Image oder den S3-Pfad zu einem in einem Amazon-S3-Bucket gespeicherten Bild angeben. Beispielsweise:

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

Wenn sich das Bild in einem Amazon-S3-Bucket befindet, stellen Sie sicher, dass es sich um denselben Bucket handelt, den Sie in Schritt 15 von Schritt 1: Erstellen Sie eine AWS Lambda Funktion (Konsole) angegeben haben.

Ist dies erfolgreich, wird eine Liste von Labels ausgegeben, die im Bild gefunden wurden. Wenn keine Labels zurückgegeben werden, sollten Sie den Konfidenzwert, den Sie in Schritt 7 von Schritt 1: Erstellen Sie eine AWS Lambda Funktion (Konsole) festgelegt haben, verringern.

Wenn Sie mit der Lambda-Funktion fertig sind und das Modell nicht von anderen Anwendungen verwendet wird, beenden Sie das Modell. Denken Sie daran, das Modell zu starten, wenn Sie das nächste Mal die Lambda-Funktion verwenden möchten.