Detectar as anomalias de uma imagem

Para detectar anomalias em uma imagem com um modelo treinado do Amazon Lookout for Vision, você chama a operação DetectAnomalies. O resultado de DetectAnomalies inclui uma previsão booleana que classifica a imagem como contendo uma ou mais anomalias e um valor de confiança para a previsão. Se o modelo for um modelo de segmentação de imagem, o resultado também incluirá uma máscara colorida mostrando as posições dos diferentes tipos de anomalias.

As imagens que você fornece DetectAnomalies devem ter as mesmas dimensões de largura e altura das imagens que você usou para treinar o modelo.

A DetectAnomalies aceita imagens no formato PNG ou JPG. Recomendamos que as imagens estejam no mesmo formato de codificação e compressão que as usadas para treinar o modelo. Por exemplo, se você treinar o modelo com imagens no formato PNG, chame DetectAnomalies com imagens no formato PNG.

Antes de ligar DetectAnomalies, você deve primeiro iniciar seu modelo com a StartModel operação. Para obter mais informações, consulte Iniciar seu modelo do Amazon Lookout for Vision. Você é cobrado pela quantidade de tempo, em minutos, que um modelo é executado e pelo número de unidades de detecção de anomalias que seu modelo usa. Se você não estiver usando um modelo, use a StopModel operação para parar seu modelo. Para obter mais informações, consulte Parar o modelo do Amazon Lookout for Vision.

Tópicos

• Como chamar o DetectAnomalias
• Entender a resposta do DetectAnomalias
• Determinar se uma imagem é anômala
• Exibindo informações de classificação e segmentação
• Encontrando anomalias com uma função AWS Lambda

Como chamar o DetectAnomalias

Para chamar DetectAnomalies, especifique o seguinte:

• Projeto — O nome do projeto que contém o modelo que deseja usar.

• ModelVersion — A versão do modelo que você deseja usar.

• ContentType — O tipo de imagem que você deseja analisar. Os valores válidos são image/png (imagens no formato PNG) e image/jpeg (imagens no formato JPG).

• Corpo — Os bytes binários não codificados que representam a imagem.

  A imagem deve ter as mesmas dimensões das imagens usadas para treinar o modelo.

O exemplo a seguir mostra como chamar DetectAnomalies. Você pode usar a resposta da função dos exemplos em Python e Java para chamar funções em Determinar se uma imagem é anômala

AWS CLI

Esse comando da AWS CLI exibe a saída JSON da operação da CLI DetectAnomalies. Alterar os valores dos seguintes parâmetros de entrada:

• project name com o nome do projeto que você deseja usar.

• model version com a versão do modelo que você deseja usar.

• content type com o tipo de imagem que você deseja usar. Os valores válidos são image/png (imagens no formato PNG) e image/jpeg (imagens no formato JPG).

• file name com o caminho e o nome do arquivo da imagem que você deseja usar. Certifique-se de que o tipo de arquivo corresponda ao valor de content-type.

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

Python

Para obter o exemplo de código completo, consulte GitHub.

    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));
    }

Entender a resposta do DetectAnomalias

A resposta DetectAnomalies varia de acordo com o tipo do modelo que você treina (modelo de classificação ou modelo de segmentação). Em ambos os casos, a resposta é um objeto DetectAanomalyResult.

Modelo de classificação

Se seu modelo for um Modelo de classificação de imagens, a resposta de DetectAnomalies conterá o seguinte:

• isAnomalous — Um indicador booleano de que a imagem contém uma ou mais anomalias.

• Confiança — A confiança que o Amazon Lookout for Vision tem na precisão da previsão da anomalia (IsAnomalous). Confidenceé um valor de ponto flutuante entre 0 e 1. Um valor mais alto indica uma maior confiança.

• Fonte — Informações sobre a imagem passada para DetectAnomalies.

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

Você determina se uma imagem é anômala verificando o IsAnomalous campo e confirmando que o Confidence valor é alto o suficiente para suas necessidades.

Se você achar que os valores de confiança retornados por DetectAnomalies são muito baixos, considere retreinar o modelo. Para ver um código demonstrativo, consulte Classificação.

Modelo de segmentação

Se seu modelo for um Modelo de segmentação de imagens, a resposta inclui informações de classificação e informações de segmentação, como uma máscara de imagem e tipos de anomalia. As informações de classificação são calculadas separadamente das informações de segmentação e você não deve presumir uma relação entre elas. Se você não receber informações de segmentação na resposta, verifique se você tem a versão mais recente do AWS SDK instalada (AWS Command Line Interface, se estiver usando a AWS CLI). Para ver um código demonstrativo, consulte Segmentação e Exibindo informações de classificação e segmentação.

• isAnomalous (classificação) — Um indicador booleano que classifica a imagem como normal ou anômala.

• Confiança (classificação) — A confiança que o Amazon Lookout for Vision tem na precisão da classificação da imagem (IsAnomalous). Confidence é um valor de ponto flutuante entre 0 e 1. Um valor mais alto indica uma maior confiança.

• Fonte — Informações sobre a imagem passada para DetectAnomalies.

• AnomalyMask (segmentação) — Uma máscara de pixels que cobre anomalias encontradas na imagem analisada. Pode haver várias anomalias na imagem. A cor dos mapas de uma máscara indica o tipo de anomalia. As cores da máscara são mapeadas para as cores atribuídas aos tipos de anomalias no conjunto de dados de treinamento. Para encontrar o tipo de anomalia a partir da cor da máscara, verifique Color o campo PixelAnomaly de cada anomalia retornada na lista Anomalies. Para ver um código demonstrativo, consulte Exibindo informações de classificação e segmentação.

• Anomalias (segmentação) — Uma lista de anomalias encontradas na imagem. Cada anomalia inclui o tipo de anomalia (Name) e as informações de pixel (PixelAnomaly). TotalPercentageArea é a área percentual da imagem que a anomalia cobre. Color é a cor da máscara para a anomalia.

  O primeiro elemento na lista é sempre um tipo de anomalia que representa o fundo da imagem (BACKGROUND) e não deve ser considerado uma anomalia. O Amazon Lookout for Vision adiciona automaticamente o tipo de anomalia em segundo plano à resposta. Você não precisa declarar um tipo de anomalias de fundo do seu conjunto de dados.

{
    "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....."
    }
}