Auffinden von Anomalien mit einemAWS Lambdawirken

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

Wählen Sie Funktion erstellen aus. Weitere Informationen finden Sie unterErstellen Sie eine Lambda-Funktion mit der Konsole.

Wählen Sie die folgenden Optionen.

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

Wählen Sie auf der Funktionsseite dieKonfigurationTab.

Auf derUmgebungsvariablenFenster, wählenBearbeiten.

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

Wählen SieSpeichernum die Umgebungsvariablen zu speichern.

Auf derBerechtigungenFenster, UnterName der Rolle, wählen Sie die Ausführungsrolle aus, um die Rolle in der IAM-Konsole zu öffnen.

In derBerechtigungenTab, wähleBerechtigungen hinzufügenund dannInline-Richtlinie erstellen.

Wählen SieJSONund ersetzen Sie die bestehende Richtlinie durch die folgende Richtlinie.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": "lookoutvision:DetectAnomalies",
            "Resource": "*",
            "Effect": "Allow",
            "Sid": "DetectAnomaliesAccess"
        }
    ]
}

Wählen Sie Weiter aus.

InEinzelheiten der Richtlinie, geben Sie einen Namen für die Richtlinie ein, z. B.DetectAnomalies-Zugang.

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. ErsetzenBucket-/Ordnerpfadmit dem Amazon 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, z. B.Zugriff auf den S3 Bucket.

Öffnen Sie eine Befehlszeile und geben Sie 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 es in Schritt 6 dieses Verfahrens.

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

Wählen Sie im Navigationsbereich Layers aus.

Wählen Sie Create Layer (Ebene erstellen) aus.

Geben Sie einen Name (Namen) und eine Description (Beschreibung) ein.

Wählen SieLaden Sie eine ZIP-Datei hochund wählehochladen.

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

Wählen Sie für kompatible LaufzeitenPython 3.9.

Wählen SieErstellenum die Ebene zu erstellen.

Wählen Sie das Menüsymbol im Navigationsbereich.

Wählen Sie im Navigationsbereich Functions aus.

Wählen Sie in der Ressourcenliste die Funktion aus, die Sie in erstellt habenSchritt 1: Erstellen Sie eineAWS LambdaFunktion (Konsole).

Wählen Sie die Registerkarte Code (Code).

In derLagenAbschnitt, wählenEine Ebene hinzufügen.

Wählen SieBenutzerdefinierte Ebenen.

InBenutzerdefinierte Ebenen, wählen Sie den Layer-Namen, den Sie in Schritt 6 eingegeben haben.

InVersionwählen Sie die Layer-Version, die 1 sein sollte.

Wählen Sie Add (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 erstellt habenSchritt 1: Erstellen Sie eineAWS LambdaFunktion (Konsole).

Wählen Sie die Registerkarte Code (Code).

InQuellcode, ersetze den Code inlambda_function.pymit den folgenden:

# 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 Amazon Lookout for Vision model.
"""
import base64
import imghdr
from os import environ
from io import BytesIO
import logging
import boto3

from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)


# Get the model and confidence.
project_name = environ['PROJECT_NAME']
model_version = environ['MODEL_VERSION']
min_confidence = int(environ.get('CONFIDENCE', 50))

lookoutvision_client = boto3.client('lookoutvision')


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:
        
        file_name = ""

        # Determine image source.
        if 'image' in event:
            # Decode the encoded image
            image_bytes = event['image'].encode('utf-8')
            img_b64decoded = base64.b64decode(image_bytes)
            image_type = get_image_type(img_b64decoded)
            image = BytesIO(img_b64decoded)
            file_name = event['filename']

        elif 'S3Object' in event:
            bucket = boto3.resource('s3').Bucket(event['S3Object']['Bucket'])
            image_object = bucket.Object(event['S3Object']['Name'])
            image = image_object.get().get('Body').read()
            image_type = get_image_type(image)
            file_name = f"s3://{event['S3Object']['Bucket']}/{event['S3Object']['Name']}"

        else:
            raise ValueError(
                'Invalid image source. Only base 64 encoded image bytes or images in S3 buckets are supported.')

        # Analyze the image.
        response = lookoutvision_client.detect_anomalies(
            ProjectName=project_name,
            ContentType=image_type,
            Body=image,
            ModelVersion=model_version)

        reject = reject_on_classification(
            response['DetectAnomalyResult'], confidence_limit=float(environ['CONFIDENCE'])/100)

        status = "anomalous" if reject else "normal"

        lambda_response = {
            "statusCode": 200,
            "body": {
                "Reject": reject,
                "RejectMessage": f"Image {file_name} is {status}."
            }
        }

    except ClientError as err:
        error_message = f"Couldn't analyze {file_name}. " + \
            err.response['Error']['Message']

        lambda_response = {
            'statusCode': 400,
            'body': {
                "Error": err.response['Error']['Code'],
                "ErrorMessage": error_message,
                "Image": file_name
            }
        }
        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),
                "Image": event['filename']
            }
        }
        logger.error("Error function %s: %s",
                     context.invoked_function_arn, format(val_error))

    return lambda_response

def get_image_type(image):
    """
    Gets the format of the image. Raises an error
    if the type is not PNG or JPEG.
    :param image: The image that you want to check.
    :return The type of the image.

    """
    image_type = imghdr.what(None, image)

    if image_type == "jpeg":
        content_type = "image/jpeg"
    elif image_type == "png":
        content_type = "image/png"
    else:
        logger.info("Invalid image type")
        raise ValueError(
            "Invalid file format. Supply a jpeg or png format file.")
    return content_type


def reject_on_classification(prediction, confidence_limit):
    """
    Returns True if the anomaly confidence is greater than or equal to
    the supplied confidence limit.
    :param image: The name of the image file that was analyzed.
    :param prediction: The DetectAnomalyResult object returned from DetectAnomalies
    :param confidence_limit: The minimum acceptable confidence. Float value between 0 and 1.
    :return: True if the error condition indicates an anomaly, otherwise False.
    """

    reject = False

    if prediction['IsAnomalous'] and prediction['Confidence'] >= confidence_limit:
        reject = True
        reject_info = (f"Rejected: Anomaly confidence ({prediction['Confidence']:.2%}) is greater"
                       f" than limit ({confidence_limit:.2%})")
        logger.info("%s", reject_info)

    if not reject:
        logger.info("No anomalies found.")
    return reject

Wählen SieBereitstellenum Ihre Lambda-Funktion bereitzustellen.

Gehen Sie wie folgt vor, falls Sie dies noch nicht getan haben:

1. Stellen Sie sicher, dass der Benutzer, der den Client-Code verwendet,lambda:InvokeFunctionErlaubnis. Sie können die folgenden Berechtigungen verwenden.

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

   Den ARN für Ihre Lambda-Funktionsfunktion finden Sie in der Funktionsübersicht in derLambda-Konsole.

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

   • Benutzer und Gruppen in AWS IAM Identity Center:

     Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter Erstellen eines Berechtigungssatzes im AWS IAM Identity Center-Benutzerhandbuch.

   • Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:

     Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anweisungen unter Erstellen einer Rolle für einen externen Identitätsanbieter (Verbund) im IAM-Benutzerhandbuch.

   • IAM-Benutzer:

     • Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Folgen Sie den Anweisungen unter Erstellen einer Rolle für einen IAM-Benutzer im IAM-Benutzerhandbuch.

     • (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter Hinzufügen von Berechtigungen zu einem Benutzer (Konsole) im IAM-Benutzerhandbuch.

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

3. Starten Sie das Modelldie Sie in Schritt 7 von angegeben habenSchritt 1: Erstellen Sie eineAWS LambdaFunktion (Konsole).

Speichern Sie den folgenden Code in einer Datei mit dem Namenclient.py.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose: Shows how to call the anomaly detection
AWS Lambda function.
"""
from botocore.exceptions import ClientError

import argparse
import logging
import base64
import json
import boto3
from os import environ

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, "filename": image}

    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()

        # Analyze image and display results.

        result = analyze_image(args.function, args.image)

        status = result['statusCode']

        if status == 200:
            classification = result['body']
            print(f"classification: {classification['Reject']}")
            print(f"Message: {classification['RejectMessage']}")
        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 den Pfad zu einem lokalen Image an, das Sie analysieren möchten. Beispiele:

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

Wenn dies erfolgreich ist, ist die Ausgabe eine Klassifizierung der im Bild gefundenen Anomalien. Wenn keine Klassifizierung zurückgegeben wird, sollten Sie erwägen, den Konfidenzwert zu senken, den Sie in Schritt 7 von festgelegt habenSchritt 1: Erstellen Sie eineAWS LambdaFunktion (Konsole).

Wenn Sie mit der Lambda-Funktion fertig sind und das Modell nicht von anderen Anwendungen verwendet wird,Stoppen Sie das Modell. Denken Sie daranstarte das Modellwenn Sie das nächste Mal die Lambda-Funktion verwenden möchten.