DetectLabels solicitação de operação DetectLabels resposta Transformando a resposta DetectLabels

Detectar rótulos em uma imagem

Você pode usar a DetectLabelsoperação para detectar rótulos (objetos e conceitos) em uma imagem e recuperar informações sobre as propriedades de uma imagem. As propriedades da imagem incluem atributos como a cor do primeiro plano e do plano de fundo e a nitidez, o brilho e o contraste da imagem. Você pode recuperar apenas os rótulos em uma imagem, apenas as propriedades da imagem ou ambas. Para ver um exemplo, consulte Analisando imagens armazenadas em um bucket do Amazon S3.

Os exemplos a seguir usam vários AWS SDKs e o AWS CLI to callDetectLabels. Para obter informações sobre a resposta da operação DetectLabels, consulte DetectLabels resposta.

Para detectar rótulos em uma imagem

Se ainda não tiver feito isso:
1. Crie ou atualize um usuário com permissões AmazonRekognitionFullAccess e AmazonS3ReadOnlyAccess. Para ter mais informações, consulte Etapa 1: Configure uma conta da AWS e crie um usuário.
2. Instale e configure o AWS CLI e os AWS SDKs. Para ter mais informações, consulte Etapa 2: configurar os AWS SDKs AWS CLI e.
Faça upload de uma imagem que contenha um ou mais objetos, como árvores, casas e barcos, para seu bucket do S3. A imagem deve estar no formato .jpg ou .png.

Para obter instruções, consulte Como fazer upload de objetos no Amazon S3 no Guia do usuário do Amazon Simple Storage Service.

Use os exemplos a seguir para chamar a operação DetectLabels.

Java

Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de bucket e photo pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2.



package com.amazonaws.samples;
import java.util.List;

import com.amazonaws.services.rekognition.model.BoundingBox;
import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
import com.amazonaws.services.rekognition.model.DetectLabelsResult;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.Instance;
import com.amazonaws.services.rekognition.model.Label;
import com.amazonaws.services.rekognition.model.Parent;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;

public class DetectLabels {

    public static void main(String[] args) throws Exception {

        String photo = "photo";
        String bucket = "bucket";

        AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();

        DetectLabelsRequest request = new DetectLabelsRequest()
                .withImage(new Image().withS3Object(new S3Object().withName(photo).withBucket(bucket)))
                .withMaxLabels(10).withMinConfidence(75F);

        try {
            DetectLabelsResult result = rekognitionClient.detectLabels(request);
            List<Label> labels = result.getLabels();

            System.out.println("Detected labels for " + photo + "\n");
            for (Label label : labels) {
                System.out.println("Label: " + label.getName());
                System.out.println("Confidence: " + label.getConfidence().toString() + "\n");

                List<Instance> instances = label.getInstances();
                System.out.println("Instances of " + label.getName());
                if (instances.isEmpty()) {
                    System.out.println("  " + "None");
                } else {
                    for (Instance instance : instances) {
                        System.out.println("  Confidence: " + instance.getConfidence().toString());
                        System.out.println("  Bounding box: " + instance.getBoundingBox().toString());
                    }
                }
                System.out.println("Parent labels for " + label.getName() + ":");
                List<Parent> parents = label.getParents();
                if (parents.isEmpty()) {
                    System.out.println("  None");
                } else {
                    for (Parent parent : parents) {
                        System.out.println("  " + parent.getName());
                    }
                }
                System.out.println("--------------------");
                System.out.println();
               
            }
        } catch (AmazonRekognitionException e) {
            e.printStackTrace();
        }
    }
}

AWS CLI

Esse exemplo exibe a saída JSON da operação da CLI detect-labels. Substitua os valores de bucket e photo pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. Substitua o valor de profile-name com o nome do seu perfil de desenvolvedor.


aws rekognition detect-labels --image '{ "S3Object": { "Bucket": "bucket-name", "Name": "file-name" } }' \
--features GENERAL_LABELS IMAGE_PROPERTIES \
--settings '{"ImageProperties": {"MaxDominantColors":1}, {"GeneralLabels":{"LabelInclusionFilters":["Cat"]}}}' \
--profile profile-name \
--region us-east-1

Se você estiver acessando a CLI em um dispositivo Windows, use aspas duplas em vez de aspas simples e escape das aspas duplas internas com barra invertida (ou seja, \) para resolver quaisquer erros de analisador que você possa encontrar. Para obter um exemplo, veja o seguinte:



aws rekognition detect-labels --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"file-name\"}}" --features GENERAL_LABELS IMAGE_PROPERTIES \
--settings "{\"GeneralLabels\":{\"LabelInclusionFilters\":[\"Car\"]}}" --profile profile-name --region us-east-1

Python

Este exemplo exibe os rótulos que foram detectados na imagem de entrada. Na função main, substitua os valores de bucket e photo pelos nomes do bucket e da imagem do Amazon S3 que você usou na Etapa 2. Substitua o valor de profile_name na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.


#Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

import boto3

def detect_labels(photo, bucket):

     session = boto3.Session(profile_name='profile-name')
     client = session.client('rekognition')

     response = client.detect_labels(Image={'S3Object':{'Bucket':bucket,'Name':photo}},
     MaxLabels=10,
     # Uncomment to use image properties and filtration settings
     #Features=["GENERAL_LABELS", "IMAGE_PROPERTIES"],
     #Settings={"GeneralLabels": {"LabelInclusionFilters":["Cat"]},
     # "ImageProperties": {"MaxDominantColors":10}}
     )

     print('Detected labels for ' + photo)
     print()
     for label in response['Labels']:
         print("Label: " + label['Name'])
         print("Confidence: " + str(label['Confidence']))
         print("Instances:")

         for instance in label['Instances']:
             print(" Bounding box")
             print(" Top: " + str(instance['BoundingBox']['Top']))
             print(" Left: " + str(instance['BoundingBox']['Left']))
             print(" Width: " + str(instance['BoundingBox']['Width']))
             print(" Height: " + str(instance['BoundingBox']['Height']))
             print(" Confidence: " + str(instance['Confidence']))
             print()

         print("Parents:")
         for parent in label['Parents']:
            print(" " + parent['Name'])

         print("Aliases:")
         for alias in label['Aliases']:
             print(" " + alias['Name'])

             print("Categories:")
         for category in label['Categories']:
             print(" " + category['Name'])
             print("----------")
             print()

     if "ImageProperties" in str(response):
         print("Background:")
         print(response["ImageProperties"]["Background"])
         print()
         print("Foreground:")
         print(response["ImageProperties"]["Foreground"])
         print()
         print("Quality:")
         print(response["ImageProperties"]["Quality"])
         print()

     return len(response['Labels'])

def main():
    photo = 'photo-name'
    bucket = 'bucket-name'
    label_count = detect_labels(photo, bucket)
    print("Labels detected: " + str(label_count))

if __name__ == "__main__":
    main()

.NET

Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de bucket e photo pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2.


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

using System;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;

public class DetectLabels
{
    public static void Example()
    {
        String photo = "input.jpg";
        String bucket = "bucket";

        AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

        DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
        {
            Image = new Image()
            {
                S3Object = new S3Object()
                {
                    Name = photo,
                    Bucket = bucket
                },
            },
            MaxLabels = 10,
            MinConfidence = 75F
        };

        try
        {
            DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
            Console.WriteLine("Detected labels for " + photo);
            foreach (Label label in detectLabelsResponse.Labels)
                Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Ruby

Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de bucket e photo pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2.




   # Add to your Gemfile
   # gem 'aws-sdk-rekognition'
   require 'aws-sdk-rekognition'
   credentials = Aws::Credentials.new(
      ENV['AWS_ACCESS_KEY_ID'],
      ENV['AWS_SECRET_ACCESS_KEY']
   )
   bucket = 'bucket' # the bucket name without s3://
   photo  = 'photo' # the name of file
   client   = Aws::Rekognition::Client.new credentials: credentials
   attrs = {
     image: {
       s3_object: {
         bucket: bucket,
         name: photo
       },
     },
     max_labels: 10
   }
  response = client.detect_labels attrs
  puts "Detected labels for: #{photo}"
  response.labels.each do |label|
    puts "Label:      #{label.name}"
    puts "Confidence: #{label.confidence}"
    puts "Instances:"
    label['instances'].each do |instance|
      box = instance['bounding_box']
      puts "  Bounding box:"
      puts "    Top:        #{box.top}"
      puts "    Left:       #{box.left}"
      puts "    Width:      #{box.width}"
      puts "    Height:     #{box.height}"
      puts "  Confidence: #{instance.confidence}"
    end
    puts "Parents:"
    label.parents.each do |parent|
      puts "  #{parent.name}"
    end
    puts "------------"
    puts ""
  end

Node.js

Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de bucket e photo pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. Substitua o valor de profile_name na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.

Se você estiver usando TypeScript definições, talvez seja necessário usar import AWS from 'aws-sdk' em vez deconst AWS = require('aws-sdk'), para executar o programa com o Node.js. Você pode consultar o AWS SDK para Javascript para obter mais detalhes. Dependendo de como você configurou suas configurações, talvez você também precise especificar sua região com AWS.config.update({region:region});.



                                
// Load the SDK
var AWS = require('aws-sdk');
const bucket = 'bucket-name' // the bucketname without s3://
const photo  = 'image-name' // the name of file

var credentials = new AWS.SharedIniFileCredentials({profile: 'profile-name'});
AWS.config.credentials = credentials;
AWS.config.update({region:'region-name'});

const client = new AWS.Rekognition();
const params = {
  Image: {
    S3Object: {
      Bucket: bucket,
      Name: photo
    },
  },
  MaxLabels: 10
}
client.detectLabels(params, function(err, response) {
  if (err) {
    console.log(err, err.stack); // if an error occurred
  } else {
    console.log(`Detected labels for: ${photo}`)
    response.Labels.forEach(label => {
      console.log(`Label:      ${label.Name}`)
      console.log(`Confidence: ${label.Confidence}`)
      console.log("Instances:")
      label.Instances.forEach(instance => {
        let box = instance.BoundingBox
        console.log("  Bounding box:")
        console.log(`    Top:        ${box.Top}`)
        console.log(`    Left:       ${box.Left}`)
        console.log(`    Width:      ${box.Width}`)
        console.log(`    Height:     ${box.Height}`)
        console.log(`  Confidence: ${instance.Confidence}`)
      })
      console.log("Parents:")
      label.Parents.forEach(parent => {
        console.log(`  ${parent.Name}`)
      })
      console.log("------------")
      console.log("")
    }) // for response.labels
  } // if
});

Java V2

Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo aqui.


//snippet-start:[rekognition.java2.detect_labels.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.DetectLabelsRequest;
import software.amazon.awssdk.services.rekognition.model.DetectLabelsResponse;
import software.amazon.awssdk.services.rekognition.model.Label;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.S3Object;
import java.util.List;

/**
* Before running this Java V2 code example, set up your development environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DetectLabels {

    public static void main(String[] args) {

        final String usage = "\n" +
            "Usage: " +
            "   <bucket> <image>\n\n" +
            "Where:\n" +
            "   bucket - The name of the Amazon S3 bucket that contains the image (for example, ,ImageBucket)." +
            "   image - The name of the image located in the Amazon S3 bucket (for example, Lake.png). \n\n";

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String bucket = args[0];
        String image = args[1];
        Region region = Region.US_WEST_2;
        RekognitionClient rekClient = RekognitionClient.builder()
            .region(region)
            .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
            .build();

        getLabelsfromImage(rekClient, bucket, image);
        rekClient.close();
    }

    // snippet-start:[rekognition.java2.detect_labels_s3.main]
    public static void getLabelsfromImage(RekognitionClient rekClient, String bucket, String image) {

        try {
            S3Object s3Object = S3Object.builder()
                .bucket(bucket)
                .name(image)
                .build() ;

            Image myImage = Image.builder()
                .s3Object(s3Object)
                .build();

            DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                .image(myImage)
                .maxLabels(10)
                .build();

            DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
            List<Label> labels = labelsResponse.labels();
            System.out.println("Detected labels for the given photo");
            for (Label label: labels) {
                System.out.println(label.name() + ": " + label.confidence().toString());
            }

        } catch (RekognitionException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }
 // snippet-end:[rekognition.java2.detect_labels.main]
}

DetectLabels solicitação de operação

A entrada de DetectLabel é uma imagem. Neste exemplo de entrada JSON, a imagem de origem é carregada de um bucket do Amazon S3. MaxLabels é o número máximo de rótulos a serem retornados na resposta. MinConfidence é a confiança mínima que o Amazon Rekognition Image deve ter na precisão da etiqueta detectada para que ela seja retornada na resposta.

Os recursos permitem que você especifique um ou mais recursos da imagem que você deseja retornar, permitindo que você selecione GENERAL_LABELS e IMAGE_PROPERTIES. A inclusão de GENERAL_LABELS retornará os rótulos detectados na imagem de entrada, enquanto a inclusão de IMAGE_PROPERTIES permitirá que você acesse a cor e a qualidade da imagem.

As configurações permitem filtrar os itens devolvidos tanto para os recursos GENERAL_LABELS quanto para os recursos IMAGE_PROPERTIES. Para etiquetas, você pode usar filtros inclusivos e exclusivos. Você também pode filtrar por rótulo específico, rótulos individuais ou por categoria de rótulo:

LabelInclusionFilters - Permite que você especifique quais rótulos você deseja incluir na resposta.
LabelExclusionFilters - Permite especificar quais rótulos você deseja excluir da resposta.
LabelCategoryInclusionFilters - Permite que você especifique quais categorias de etiquetas você deseja incluir na resposta.
LabelCategoryExclusionFilters - Permite que você especifique quais categorias de rótulos você deseja excluir da resposta.

Você também pode combinar filtros inclusivos e exclusivos de acordo com suas necessidades, excluindo alguns rótulos ou categorias e incluindo outros.

IMAGE_PROPERTIES referem-se às cores dominantes e aos atributos de qualidade de uma imagem, como nitidez, brilho e contraste. Ao detectar IMAGE_PROPERTIES, você pode especificar o número máximo de cores dominantes a serem retornadas (o padrão é 10) usando o parâmetro MaxDominantColors.


{
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "input.jpg"
        }
    },
    "MaxLabels": 10,
    "MinConfidence": 75,
    "Features": [ "GENERAL_LABELS", "IMAGE_PROPERTIES" ],
    "Settings": {
        "GeneralLabels": {
            "LabelInclusionFilters": [<Label(s)>],
            "LabelExclusionFilters": [<Label(s)>],
            "LabelCategoryInclusionFilters": [<Category Name(s)>],
            "LabelCategoryExclusionFilters": [<Category Name(s)>] 
        },
        "ImageProperties": {
            "MaxDominantColors":10
        }
    }
}

DetectLabels resposta

A resposta de DetectLabels é uma matriz de rótulos detectados na imagem e o nível de confiança em que foram detectadas.

Esta é uma resposta de exemplo de DetectLabels. O exemplo de resposta abaixo contém vários atributos retornados para GENERAL_LABELS, incluindo:

Nome: o nome do rótulo detectado. Neste exemplo, a operação detectou um objeto com o rótulo Celular.
Confiança: cada rótulo tem um nível de confiança associado. Neste exemplo, a confiança no rótulo foi de 99,36%.
Pais: os rótulos ancestrais de um rótulo detectado. Neste exemplo, o rótulo Celular tem um rótulo principal chamado Telefone.
Aliases: informações sobre possíveis aliases para o rótulo. Neste exemplo, a etiqueta Celular tem um possível alias de Celular.
Categorias: a categoria de etiqueta à qual a etiqueta detectada pertence. Neste exemplo, é Tecnologia e Computação.

A resposta para rótulos de objetos comuns inclui as informações da caixa delimitadora para a localização do rótulo na imagem de entrada. Por exemplo, o rótulo Pessoa tem uma matriz de instâncias que contém duas caixas delimitadoras. Essas são as localizações de duas pessoas detectadas na imagem.

A resposta também inclui atributos relacionados a IMAGE_PROPERTIES. Os atributos apresentados pelo recurso IMAGE_PROPERTIES são:

Qualidade: informações sobre nitidez, brilho e contraste da imagem de entrada, pontuadas entre 0 e 100. A qualidade é relatada para toda a imagem e para o plano de fundo e primeiro plano da imagem, se disponível. No entanto, o contraste é relatado apenas para a imagem inteira, enquanto a nitidez e o brilho também são relatados para fundo e primeiro plano.
Cor dominante: uma matriz das cores dominantes na imagem. Cada cor dominante é descrita com um nome de cor simplificado, uma paleta de cores CSS, valores RGB e um código hexadecimal.
Primeiro plano: informações sobre as cores, nitidez e brilho dominantes do primeiro plano da imagem de entrada.
Plano de fundo: informações sobre as cores, nitidez e brilho dominantes do fundo da imagem de entrada.

Quando GENERAL_LABELS e IMAGE_PROPERTIES são usados juntos como parâmetros de entrada, o Amazon Rekognition Image também retornará as cores dominantes dos objetos com caixas delimitadoras.

O campo LabelModelVersion contém o número da versão do modelo de detecção usado por DetectLabels.


{
   
   "Labels": [
        {
            "Name": "Mobile Phone",
            "Parents": [
              { 
                "Name": "Phone" 
              }
            ],
            "Aliases": [
              {
                "Name": "Cell Phone" 
              }
            ], 
            "Categories": [
              {
                "Name": "Technology and Computing"
              }
            ],
            "Confidence": 99.9364013671875,
            "Instances": [
                {
                    "BoundingBox": {
                        "Width": 0.26779675483703613,
                        "Height": 0.8562285900115967,
                        "Left": 0.3604024350643158,
                        "Top": 0.09245597571134567,
                    }
                    "Confidence": 99.9364013671875,
                    "DominantColors": [
                    {
                "Red": 120,
                "Green": 137,
                "Blue": 132,
                "HexCode": "3A7432",
                "SimplifiedColor": "red", 
                "CssColor": "fuscia",    
                "PixelPercentage": 40.10 
                    }       
                        ],
                }
            ]
        }
    ],
    "ImageProperties": {
        "Quality": {
            "Brightness": 40,
            "Sharpness": 40,
            "Contrast": 24,
        },
        "DominantColors": [
            {
                "Red": 120,
                "Green": 137,
                "Blue": 132,
                "HexCode": "3A7432",
                "SimplifiedColor": "red", 
                "CssColor": "fuscia",    
                "PixelPercentage": 40.10 
            }       
        ],
        "Foreground": {
            "Quality": {
                "Brightness": 40,
                "Sharpness": 40,
            },
            "DominantColors": [                
                {                    
                    "Red": 200,
                    "Green": 137,
                    "Blue": 132,
                    "HexCode": "3A7432",
                    "CSSColor": "",
                    "SimplifiedColor": "red", 
                    "PixelPercentage": 30.70             
                }          
            ],   
        }
        "Background": {
            "Quality": {
                "Brightness": 40,
                "Sharpness": 40,
            },
            "DominantColors": [                
                {                    
                    "Red": 200,
                    "Green": 137,
                    "Blue": 132,
                    "HexCode": "3A7432",
                    "CSSColor": "",
                    "SimplifiedColor": "Red", 
                    "PixelPercentage": 10.20              
                }          
            ],   
        }, 
    },
    "LabelModelVersion": "3.0"
}

Transformando a resposta DetectLabels

Ao usar a DetectLabels API, talvez você precise que a estrutura de resposta imite a estrutura de resposta da API mais antiga, na qual tanto os rótulos principais quanto os aliases estavam contidos na mesma lista.

Veja a seguir um exemplo da resposta atual da API de DetectLabels:


"Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 99.99717712402344,
            "Instances": [],
            "Parents": [
                { 
                "Name": "Phone" 
                }
             ],
            "Aliases": [
                {
                "Name": "Cell Phone" 
                }
             ]
        }
 ]

O exemplo a seguir mostra a resposta anterior da DetectLabelsAPI:


"Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 99.99717712402344,
            "Instances": [],
            "Parents": [
                {
                "Name": "Phone" 
                }
             ]
         },
         {
            "Name": "Cell Phone",
            "Confidence": 99.99717712402344,
            "Instances": [],
            "Parents": [
                { 
                "Name": "Phone" 
                }
             ]
         },
]

Se necessário, você pode transformar a resposta atual para seguir o formato da resposta mais antiga. Você pode usar o código de exemplo a seguir para transformar a resposta mais recente da API na estrutura de resposta da API anterior:

Python

O exemplo de código a seguir demonstra como transformar a resposta atual da DetectLabels API. No exemplo de código abaixo, você pode substituir o valor de EXAMPLE_INFERENCE_OUTPUT pela saída de uma operação que você executou. DetectLabels


from copy import deepcopy

LABEL_KEY = "Labels"
ALIASES_KEY = "Aliases"
INSTANCE_KEY = "Instances"
NAME_KEY = "Name"

#Latest API response sample
EXAMPLE_INFERENCE_OUTPUT = {
    "Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Aliases": [
                {
                    "Name": "Cell Phone"
                }
            ],
            "Instances":[
                {
                    "BoundingBox":{
                        "Height":0.1549897,
                        "Width":0.07747964,
                        "Top":0.50858885,
                        "Left":0.00018205095
                    },
                    "Confidence":98.401276
                }
            ]
        },
        {
            "Name": "Urban",
            "Confidence": 99.99982,
            "Categories": [
                "Colors and Visual Composition"
            ]
        }
    ]
}

def expand_aliases(inferenceOutputsWithAliases):

    if LABEL_KEY in inferenceOutputsWithAliases:
        expandInferenceOutputs = []
        for primaryLabelDict in inferenceOutputsWithAliases[LABEL_KEY]:
            if ALIASES_KEY in primaryLabelDict:
                for alias in primaryLabelDict[ALIASES_KEY]:
                    aliasLabelDict = deepcopy(primaryLabelDict)
                    aliasLabelDict[NAME_KEY] = alias[NAME_KEY]
                    del aliasLabelDict[ALIASES_KEY]
                    if INSTANCE_KEY in aliasLabelDict:
                        del aliasLabelDict[INSTANCE_KEY]
                    expandInferenceOutputs.append(aliasLabelDict)

        inferenceOutputsWithAliases[LABEL_KEY].extend(expandInferenceOutputs)

    return inferenceOutputsWithAliases


if __name__ == "__main__":

    outputWithExpandAliases = expand_aliases(EXAMPLE_INFERENCE_OUTPUT)
    print(outputWithExpandAliases)

Abaixo está um exemplo da resposta transformada:


#Output example after the transformation
{
    "Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Aliases": [
                {
                    "Name": "Cell Phone"
                }
            ],
            "Instances":[
                {
                    "BoundingBox":{
                        "Height":0.1549897,
                        "Width":0.07747964,
                        "Top":0.50858885,
                        "Left":0.00018205095
                    },
                    "Confidence":98.401276
                }
            ]
        },
        {
            "Name": "Cell Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Instances":[]
        },
        {
            "Name": "Urban",
            "Confidence": 99.99982,
            "Categories": [
                "Colors and Visual Composition"
            ]
        }
    ]
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Detectando objetos e conceitos

Detectando rótulos em um vídeo