Erkennung von Anomalien in einem Bild

Um Anomalien in einem Bild mit einem trainierten Amazon Lookout for Vision-Modell zu erkennen, rufen Sie denDetectAnomaliesBetrieb. Das Ergebnis vonDetectAnomaliesbeinhaltet eine boolesche Vorhersage, die das Bild so klassifiziert, dass es eine oder mehrere Anomalien enthält, und einen Konfidenzwert für die Vorhersage. Handelt es sich bei dem Modell um ein Bildsegmentierungsmodell, enthält das Ergebnis auch eine farbige Maske, die die Positionen verschiedener Arten von Anomalien anzeigt.

Die Bilder, die Sie zur Verfügung stellenDetectAnomaliesmüssen die gleichen Breiten- und Höhenmaße haben wie die Bilder, mit denen Sie das Modell trainiert haben.

DetectAnomaliesakzeptiert Bilder im PNG- oder JPG-Format. Wir empfehlen, dass die Bilder dasselbe Kodierungs- und Komprimierungsformat haben wie die Bilder, die zum Trainieren des Modells verwendet wurden. Wenn Sie das Modell beispielsweise mit Bildern im PNG-Format trainieren, rufen SieDetectAnomaliesmit Bildern im PNG-Format.

Vor dem AnrufDetectAnomalies, Sie müssen Ihr Modell zuerst mit dem startenStartModelBetrieb. Weitere Informationen finden Sie unter Starten Sie Ihr Amazon Lookout for Vision Vision-Modell. Ihnen wird die Zeit in Minuten, die ein Modell ausführt, und die Anzahl der Einheiten zur Erkennung von Anomalien, die Ihr Modell verwendet, in Rechnung gestellt. Wenn Sie kein Modell verwenden, verwenden Sie denStopModelOperation, um Ihr Modell zu stoppen. Weitere Informationen finden Sie unter Ihr Amazon Lookout for Vision Vision-Modell beenden.

Themen

• Aufrufen einer DetectAnomalies
• Die Antwort von verstehenDetectAnomalies
• Ermitteln, ob ein Bild anomal ist
• Anzeige von Klassifizierungs- und Segmentierungsinformationen
• Auffinden von Anomalien mit einemAWS Lambdawirken

Aufrufen einer DetectAnomalies

Um anzurufenDetectAnomalies, geben Sie Folgendes an:

• Projekt— Der Name des Projekts, das das Modell enthält, das Sie verwenden möchten.

• ModelVersion— Die Version des Modells, das Sie verwenden möchten.

• ContentType— Der Bildtyp, den Sie analysieren möchten. Gültige Werte sindimage/png(Bilder im PNG-Format) undimage/jpeg(Bilder im JPG-Format).

• Körper— Die uncodierten Binärbytes, die das Bild darstellen.

  Das Bild muss die gleichen Abmessungen haben wie die Bilder, die zum Trainieren des Modells verwendet wurden.

Das folgende Beispiel zeigt, wie man anruftDetectAnomalies. Sie können die Funktionsantwort aus den Python- und Java-Beispielen verwenden, um Funktionen in aufzurufenErmitteln, ob ein Bild anomal ist.

AWS CLI

Dieser AWS CLI-Befehl zeigt die JSON-Ausgabe für die DetectAnomalies-CLI-Operation an. Ändern Sie die Werte der folgenden Eingabeparameter:

• project namemit dem Namen des Projekts, das Sie verwenden möchten.

• model versionmit der Version des Modells, das Sie verwenden möchten.

• content typemit dem Typ des Bildes, das Sie verwenden möchten. Gültige Werte sindimage/png(Bilder im PNG-Format) undimage/jpeg(Bilder im JPG-Format).

• file namemit dem Pfad und dem Dateinamen des Bildes, das Sie verwenden möchten. Stellen Sie sicher, dass der Dateityp dem Wert von entsprichtcontent-type.

aws lookoutvision detect-anomalies  --project-name project name\
    --model-version model version\
    --content-type content type\
    --body file name \
    --profile lookoutvision-access

Python

Das vollständige Codebeispiel finden Sie unterGitHub.

    def detect_anomalies(lookoutvision_client, project_name, model_version, photo):
        """
        Calls DetectAnomalies using the supplied project, model version, and image.
        :param lookoutvision_client: A Lookout for Vision Boto3 client.
        :param project: The project that contains the model that you want to use.
        :param model_version: The version of the model that you want to use.
        :param photo: The photo that you want to analyze.
        :return: The DetectAnomalyResult object that contains the analysis results.
        """

        image_type = imghdr.what(photo)
        if image_type == "jpeg":
            content_type = "image/jpeg"
        elif image_type == "png":
            content_type = "image/png"
        else:
            logger.info("Invalid image type for %s", photo)
            raise ValueError(
                f"Invalid file format. Supply a jpeg or png format file: {photo}")


        # Get images bytes for call to detect_anomalies
        with open(photo, "rb") as image:
            response = lookoutvision_client.detect_anomalies(
                ProjectName=project_name,
                ContentType=content_type,
                Body=image.read(),
                ModelVersion=model_version)

        return response['DetectAnomalyResult']

Java V2

   public static DetectAnomalyResult detectAnomalies(LookoutVisionClient lfvClient, String projectName,
            String modelVersion,
            String photo) throws IOException, LookoutVisionException {
        /**
         * Creates an Amazon Lookout for Vision dataset from a manifest file.
         * Returns after Lookout for Vision creates the dataset.
         * 
         * @param lfvClient    An Amazon Lookout for Vision client.
         * @param projectName  The name of the project in which you want to create a
         *                     dataset.
         * @param modelVersion The version of the model that you want to use.
         *
         * @param photo        The photo that you want to analyze.
         * 
         * @return DetectAnomalyResult The analysis result from DetectAnomalies.
         */

        logger.log(Level.INFO, "Processing local file: {0}", photo);

        // Get image bytes.

        InputStream sourceStream = new FileInputStream(new File(photo));
        SdkBytes imageSDKBytes = SdkBytes.fromInputStream(sourceStream);
        byte[] imageBytes = imageSDKBytes.asByteArray();

        // Get the image type. Can be image/jpeg or image/png.
        String contentType = getImageType(imageBytes);

        // Detect anomalies in the supplied image.
        DetectAnomaliesRequest request = DetectAnomaliesRequest.builder().projectName(projectName)
                .modelVersion(modelVersion).contentType(contentType).build();

        DetectAnomaliesResponse response = lfvClient.detectAnomalies(request,
                RequestBody.fromBytes(imageBytes));

        /*
         * Tip: You can also use the following to analyze a local file.
         * Path path = Paths.get(photo);
         * DetectAnomaliesResponse response = lfvClient.detectAnomalies(request, path);
         */
        DetectAnomalyResult result = response.detectAnomalyResult();

        String prediction = "Prediction: Normal";

        if (Boolean.TRUE.equals(result.isAnomalous())) {
            prediction = "Prediction: Anomalous";
        }

        // Convert confidence to percentage.
        NumberFormat defaultFormat = NumberFormat.getPercentInstance();
        defaultFormat.setMinimumFractionDigits(1);
        String confidence = String.format("Confidence: %s", defaultFormat.format(result.confidence()));

        // Log classification result.
        String photoPath = "File: " + photo;
        String[] imageLines = { photoPath, prediction, confidence };
        logger.log(Level.INFO, "Image: {0}\nAnomalous: {1}\nConfidence {2}", imageLines);

        return result;

    }

    // Gets the image mime type. Supported formats are image/jpeg and image/png.
    private static String getImageType(byte[] image) throws IOException {

        InputStream is = new BufferedInputStream(new ByteArrayInputStream(image));
        String mimeType = URLConnection.guessContentTypeFromStream(is);

        logger.log(Level.INFO, "Image type: {0}", mimeType);

        if (mimeType.equals("image/jpeg") || mimeType.equals("image/png")) {
            return mimeType;
        }
        // Not a supported file type.
        logger.log(Level.SEVERE, "Unsupported image type: {0}", mimeType);
        throw new IOException(String.format("Wrong image type. %s format isn't supported.", mimeType));
    }

Die Antwort von verstehenDetectAnomalies

Die Antwort vonDetectAnomaliesvariiert je nach Typ des Modells, das Sie trainieren (Klassifizierungsmodell oder Segmentierungsmodell). In beiden Fällen ist die Antwort eineDetectAnomalyResultObjekt.

Klassifizierungsmodell

Wenn Ihr Modell einBildklassifizierungsmodell, die Antwort vonDetectAnomaliesenthält Folgendes:

• IsAnomalous— Ein boolescher Indikator dafür, dass das Bild eine oder mehrere Anomalien enthält.

• Selbstvertrauen— Das Vertrauen, das Amazon Lookout for Vision in die Genauigkeit der Anomalieprognose hat (IsAnomalous).Confidenceist ein Fließkommawert zwischen 0 und 1. Ein höherer Wert weist auf ein höheres Vertrauen hin.

• Quelle— Informationen über das übergebene BildDetectAnomalies.

{
    "DetectAnomalyResult": {
        "Source": {
            "Type": "direct"
        },
        "IsAnomalous": true,
        "Confidence": 0.9996867775917053
    }
}

Sie stellen fest, ob in einem Bild eine Anomalie vorliegt, indem Sie dieIsAnomalousFeld und bestätige, dassConfidenceDer Wert ist hoch genug für Ihre Bedürfnisse.

Wenn Sie die Konfidenzwerte finden, die zurückgegeben wurden vonDetectAnomaliessind zu niedrig, erwägen Sie eine Umschulung des Modells. Beispielcode finden Sie unter Klassifizierung.

Segmentierungsmodell

Wenn Ihr Modell einBildsegmentierungsmodell, enthält die Antwort Klassifikationsinformationen und Segmentierungsinformationen, z. B. eine Bildmaske und Anomalietypen. Klassifizierungsinformationen werden getrennt von Segmentierungsinformationen berechnet, und Sie sollten nicht von einer Beziehung zwischen ihnen ausgehen. Wenn Sie in der Antwort keine Segmentierungsinformationen erhalten, überprüfen Sie, ob Sie über die neueste Version vonAWSSDK installiert (AWS Command Line Interface, wenn Sie das verwendenAWS CLI). Beispielcode finden Sie unterSegmentierungundAnzeige von Klassifizierungs- und Segmentierungsinformationen.

• IsAnomalous(Klassifizierung) — Ein boolescher Indikator, der das Bild entweder als normal oder anomal klassifiziert.

• Selbstvertrauen(Klassifizierung) — Das Vertrauen, das Amazon Lookout for Vision in die Genauigkeit der Klassifizierung des Bildes hat (IsAnomalous).Confidenceist ein Fließkommawert zwischen 0 und 1. Ein höherer Wert weist auf ein höheres Vertrauen hin.

• Quelle— Informationen über das übergebene BildDetectAnomalies.

• AnomalyMask(Segmentierung) — Eine Pixelmaske, die Anomalien im analysierten Bild verdeckt. Das Bild kann mehrere Anomalien aufweisen. Die Farbe einer Maskenkarte gibt die Art einer Anomalie an. Die Maskenfarben entsprechen den Farben, die den Anomalietypen im Trainingsdatensatz zugewiesen sind. Um den Anomalietyp anhand einer Maskenfarbe zu ermitteln, klicken SieColorin derPixelAnomalyFeld jeder Anomalie, die in der zurückgegeben wurdeAnomaliesListe. Beispielcode finden Sie unter Anzeige von Klassifizierungs- und Segmentierungsinformationen.

• Anomalien(Segmentierung) — Eine Liste der im Bild gefundenen Anomalien. Jede Anomalie umfasst den Anomalietyp (Name) und Pixelinformationen (PixelAnomaly).TotalPercentageAreaist der prozentuale Bereich des Bildes, den die Anomalie bedeckt.Colorist die Maskenfarbe für die Anomalie.

  Das erste Element in der Liste ist immer ein Anomalietyp, der den Bildhintergrund darstellt (BACKGROUND) und sollte nicht als Anomalie betrachtet werden. Amazon Lookout for Vision fügt der Antwort automatisch den Typ der Hintergrundanomalie hinzu. Sie müssen in Ihrem Datensatz keinen Hintergrundanomalietyp deklarieren.

{
    "DetectAnomalyResult": {
        "Source": {
            "Type": "direct"
        },
        "IsAnomalous": true,
        "Confidence": 0.9996814727783203,
        "Anomalies": [
            {
                "Name": "background",
                "PixelAnomaly": {
                    "TotalPercentageArea": 0.998999834060669,
                    "Color": "#FFFFFF"
                }
            },
            {
                "Name": "scratch",
                "PixelAnomaly": {
                    "TotalPercentageArea": 0.0004034999874420464,
                    "Color": "#7ED321"
                }
            },
            {
                "Name": "dent",
                "PixelAnomaly": {
                    "TotalPercentageArea": 0.0005966666503809392,
                    "Color": "#4DD8FF"
                }
            }
        ],
        "AnomalyMask": "iVBORw0....."
    }
}