DetectLabels solicitud de operación DetectLabels respuesta Transformar la DetectLabels respuesta

Detección de etiquetas en una imagen

Puede utilizar la DetectLabelsoperación para detectar etiquetas (objetos y conceptos) en una imagen y recuperar información sobre las propiedades de la imagen. Las propiedades de la imagen incluyen atributos como el color del primer plano y del fondo y la nitidez, el brillo y el contraste de la imagen. Puede recuperar solo las etiquetas de una imagen, solo las propiedades de la imagen o ambas. Para ver un ejemplo, consulte Análisis de imágenes almacenadas en un bucket de Amazon S3.

En los ejemplos siguientes se utilizan varios AWS SDK y la función AWS CLI to callDetectLabels. Para obtener más información sobre la respuesta de la operación DetectLabels, consulte DetectLabels respuesta.

Para detectar las etiquetas en una imagen

Si aún no lo ha hecho:
1. Cree o actualice un usuario con los permisos AmazonRekognitionFullAccess y AmazonS3ReadOnlyAccess. Para obtener más información, consulte Paso 1: Configurar una cuenta de AWS y crear un usuario.
2. Instale y configure los AWS CLI y los AWS SDK. Para obtener más información, consulte Paso 2: Configurar los SDK AWS CLI y AWS.
Suba una imagen que contenga uno o varios objetos, como árboles, casas o barcos, en el bucket de S3. La imagen debe estar en formato .jpg o .png.

Para ver las instrucciones, consulte Carga de objetos en Amazon S3 en la Guía del usuario de Amazon Simple Storage Service.

Consulte los siguientes ejemplos para llamar a la operación DetectLabels.

Java



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

Este ejemplo muestra la salida de JSON de la operación detect-labels de la CLI. Reemplace los valores de bucket y photo por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 2. Sustituya el valor de profile-name de por el nombre de su perfil de desarrollador.


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

Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente:



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 ejemplo muestra las etiquetas que se han detectado en la imagen de entrada. En la función main, cambie los valores de bucket y photo por los nombre del bucket de Amazon S3 y la imagen que utilizó en el paso 2. Sustituya el valor de profile_name en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador.


#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


//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




   # 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 ejemplo muestra una lista de las etiquetas que se han detectado en la imagen de entrada. Reemplace los valores de bucket y photo por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 2. Sustituya el valor de profile_name en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador.

Si utiliza TypeScript definiciones, puede que necesite utilizarlas en import AWS from 'aws-sdk' lugar deconst AWS = require('aws-sdk'), para ejecutar el programa con Node.js. Puede consultar el AWS SDK para Javascript si quiere obtener más información. En función de cómo tenga establecidas las opciones de configuración, es posible que también tenga que especificar su región con 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

Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo aquí.


//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 solicitud de operación

La entrada de DetectLabel es una imagen. En este ejemplo de entrada de JSON, la imagen de origen se carga desde un bucket de Amazon S3. MaxLabels es el número máximo de etiquetas que se devuelven en la respuesta. MinConfidence es el nivel mínimo de confianza que debe tener Amazon Rekognition Image en la precisión de la etiqueta detectada para que se devuelva en la respuesta.

Características le permite especificar una o más características de la imagen que desea que se devuelvan, lo que le permite seleccionar GENERAL_LABELS y IMAGE_PROPERTIES. Incluir GENERAL_LABELS devolverá las etiquetas detectadas en la imagen de entrada, mientras que incluir IMAGE_PROPERTIES le permitirá acceder al color y la calidad de la imagen.

La configuración le permite filtrar los artículos devueltos por sus características GENERAL_LABELS y IMAGE_PROPERTIES. Para las etiquetas, puede usar filtros inclusivos y exclusivos. También puede filtrar por etiquetas específicas, etiquetas individuales o por categoría de etiquetas:

LabelInclusionFilters - Le permite especificar qué etiquetas desea incluir en la respuesta.
LabelExclusionFilters - Le permite especificar qué etiquetas desea excluir de la respuesta.
LabelCategoryInclusionFilters - Le permite especificar qué categorías de etiquetas desea incluir en la respuesta.
LabelCategoryExclusionFilters - Le permite especificar qué categorías de etiquetas desea que se excluyan de la respuesta.

También puede combinar filtros inclusivos y exclusivos según sus necesidades, excluyendo algunas etiquetas o categorías e incluyendo otras.

IMAGE_PROPERTIES hace referencia a los colores dominantes y a los atributos de calidad de una imagen, como la nitidez, el brillo y el contraste. Al realizar la detección, IMAGE_PROPERTIES puede especificar el número máximo de colores dominantes que desea devolver (el valor predeterminado es 10) mediante el 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 respuesta

La respuesta de DetectLabels es una matriz de las etiquetas detectadas en la imagen y el nivel de confianza por el que se detectan.

A continuación se muestra un ejemplo de respuesta de DetectLabels. El ejemplo de respuesta que aparece a continuación contiene una variedad de atributos devueltos para GENERAL_LABELS, entre los que se incluyen:

Name: el nombre de la etiqueta detectada. En este ejemplo, la operación detectó un objeto con la etiqueta Teléfono móvil.
Confidence: cada etiqueta tiene un nivel de confianza asociado. En este ejemplo, la confianza de la etiqueta era del 99,36 %.
Parents: las etiquetas antecesoras de una etiqueta detectada. En este ejemplo, la etiqueta Teléfono móvil tiene una etiqueta principal llamada Teléfono.
Aliases: información sobre los posibles alias de la etiqueta. En este ejemplo, la etiqueta Teléfono móvil tiene un posible alias de Móvil.
Categories: la categoría de etiqueta a la que pertenece la etiqueta detectada. En este ejemplo, es Tecnología e Informática.

La respuesta para las etiquetas de objetos comunes incluye información del cuadro delimitador para localizar la etiqueta en la imagen de entrada. Por ejemplo, la etiqueta Person (persona) tiene una matriz de instancias que contiene dos cuadros delimitadores. Se trata de las ubicaciones de dos personas detectadas en la imagen.

La respuesta también incluye atributos relacionados con IMAGE_PROPERTIES. Los atributos que presenta la característica IMAGE_PROPERTIES son:

Quality: información sobre la nitidez, el brillo y el contraste de la imagen de entrada, puntuada entre 0 y 100. La calidad se indica para toda la imagen y para el fondo y el primer plano de la imagen, si están disponibles. Sin embargo, el contraste solo se indica para toda la imagen, mientras que la nitidez y el brillo también se indican para el fondo y el primer plano.
Dominant Color: conjunto de los colores dominantes de la imagen. Cada color dominante se describe con un nombre de color simplificado, una paleta de colores CSS, valores RGB y un código hexadecimal.
Foreground: información sobre los colores, la nitidez y el brillo dominantes del primer plano de la imagen de entrada.
Background: información sobre los colores, la nitidez y el brillo dominantes del fondo de la imagen de entrada.

Cuando GENERAL_LABELS e IMAGE_PROPERTIES se utilizan juntos como parámetros de entrada, Amazon Rekognition Image también devolverá los colores dominantes de los objetos con cuadros delimitadores.

El campo LabelModelVersion contiene el número de versión del modelo de detección que DetectLabels utiliza.


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

Transformar la DetectLabels respuesta

Cuando utilices la DetectLabels API, es posible que necesites que la estructura de respuesta de la API sea similar a la anterior, en la que tanto las etiquetas principales como los alias estaban contenidos en la misma lista.

A continuación, se muestra un ejemplo de la respuesta actual de la API de: DetectLabels


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

En el siguiente ejemplo, se muestra la respuesta anterior de la DetectLabelsAPI:


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

Si es necesario, puede transformar la respuesta actual para que siga el formato de la respuesta anterior. Puede usar el siguiente código de ejemplo para transformar la última respuesta de la API en la estructura de respuesta de la API anterior:

Python

En el siguiente ejemplo de código, se muestra cómo transformar la respuesta actual de la DetectLabels API. En el siguiente ejemplo de código, puedes reemplazar el valor de EXAMPLE_INFERENCE_OUTPUT por el resultado de una DetectLabels operación que hayas ejecutado.


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)

A continuación se ofrece un ejemplo de respuesta 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"
            ]
        }
    ]
}

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Detección de objetos y conceptos

Detección de etiquetas en un vídeo