Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Rilevamento di etichette in un'immagine
È possibile utilizzare l'DetectLabelsoperazione per rilevare etichette (oggetti e concetti) in un'immagine e recuperare informazioni sulle proprietà di un'immagine. Le proprietà dell'immagine includono attributi come il colore del primo piano e dello sfondo e la nitidezza, la luminosità e il contrasto dell'immagine. È possibile recuperare solo le etichette di un'immagine, solo le proprietà dell'immagine o entrambe. Per vedere un esempio, consulta Analisi di immagini archiviate in un bucket Amazon S3.
Gli esempi seguenti utilizzano vari AWS SDK e la chiamata AWS CLI to. DetectLabels Per informazioni sulla risposta dell'operazione DetectLabels, consulta DetectLabels risposta.
Per rilevare le etichette in un'immagine
-
Se non lo hai già fatto:
Crea o aggiorna un utente con le autorizzazioni AmazonRekognitionFullAccess e AmazonS3ReadOnlyAccess. Per ulteriori informazioni, consulta Fase 1: impostazione di un account AWS e creazione di un utente.
Installa e configura AWS CLI gli AWS SDK. Per ulteriori informazioni, consulta Passaggio 2: configura gli AWS SDK AWS CLI e.
-
Carica nel bucket S3 un'immagine contenente uno o più oggetti, ad esempio alberi, abitazioni e barche. L'immagine deve essere in formato .jpg o .png.
Per le istruzioni, consulta Caricamento di oggetti in Amazon S3 nella Guida per l'utente di Amazon Simple Storage Service.
-
Utilizzare i seguenti esempi per richiamare l'operazione DetectLabels.
- Java
-
Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 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
-
Questo esempio mostra l'output JSON dell'operazione CLI detect-labels. Sostituisci i valori bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di profile-name con il nome del tuo profilo di sviluppatore.
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 accedi alla CLI da un dispositivo Windows, usa le virgolette doppie anziché le virgolette singole ed evita le virgolette doppie interne tramite barra rovesciata (ovvero, \) per risolvere eventuali errori del parser che potresti riscontrare. Per un esempio, consulta quanto segue:
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
Questo esempio mostra le etichette rilevate nell'immagine di input. Nella funzione main, sostituisci i valori di bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di profile_name nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.
#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
-
Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 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
-
Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 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
-
Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di profile_name nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.
Se si utilizzano TypeScript definizioni, potrebbe essere necessario utilizzare import AWS from 'aws-sdk' invece diconst
AWS = require('aws-sdk'), per eseguire il programma con Node.js. Puoi consultare l'AWS
SDK per Javascript per maggiori dettagli. A seconda di come sono state impostate le configurazioni, potrebbe essere necessario specificare anche la regione 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
-
Questo codice è tratto dal GitHub repository degli esempi di AWS Documentation SDK. Guarda l'esempio completo qui.
//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 richiesta di operazione
L'input per DetectLabel è un'immagine. In questo input JSON di esempio, l'immagine di origine viene caricata da un bucket Amazon S3. MaxLabels è il numero massimo di etichette da restituire in una risposta. MinConfidence è l'affidabilità minima che Immagini Amazon Rekognition deve avere nella precisione dell'etichetta rilevata per ottenerne la restituzione nella risposta.
Features consente di specificare una o più caratteristiche dell'immagine che si desidera restituire, consentendoti di selezionare GENERAL_LABELS eIMAGE_PROPERTIES. Includere GENERAL_LABELS restituirà le etichette rilevate nell'immagine di input, mentre includere IMAGE_PROPERTIES consentirà di accedere al colore e alla qualità dell'immagine.
Le impostazioni ti consentono di filtrare gli articoli restituiti sia per le funzionalità GENERAL_LABELS che per IMAGE_PROPERTIES. Per le etichette puoi utilizzare filtri inclusivi ed esclusivi. Puoi anche filtrare per etichette singole, specifiche per etichetta o per categoria di etichette:
-
LabelInclusionFilters - Consente di specificare quali etichette si desidera includere nella risposta.
-
LabelExclusionFilters - Consente di specificare quali etichette si desidera escludere dalla risposta.
-
LabelCategoryInclusionFilters - Consente di specificare quali categorie di etichette si desidera includere nella risposta.
-
LabelCategoryExclusionFilters - Consente di specificare quali categorie di etichette si desidera escludere dalla risposta.
Puoi anche combinare filtri inclusivi ed esclusivi in base alle tue esigenze, escludendo alcune etichette o categorie e includendone altre.
IMAGE_PROPERTIES fanno riferimento ai colori e agli attributi di qualità dominanti di un'immagine come nitidezza, luminosità e contrasto. Durante il rilevamento IMAGE_PROPERTIES è possibile specificare il numero massimo di colori dominanti da restituire (il valore predefinito è 10) utilizzando il parametro 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 risposta
La risposta di DetectLabels è una matrice di etichette rilevate nell'immagine e il livello di affidabilità con cui sono state rilevate.
Di seguito è riportata una risposta di esempio da DetectLabels. La risposta di esempio seguente contiene una serie di attributi restituiti per GENERAL_LABELS, tra cui:
-
Nome - Il nome dell'etichetta rilevata. In questo esempio, l'operazione ha rilevato un oggetto con l'etichetta Mobile Phone.
-
Affidabilità - A ogni etichetta è associato un livello di affidabilità. In questo esempio, l'affidabilità dell'etichetta era del 99,36%.
-
Genitori - le etichette degli antenati per un'etichetta rilevata. In questo esempio, l'etichetta Mobile Phone ha un'etichetta principale denominata Phone.
-
Alias - Informazioni sui possibili alias per l'etichetta. In questo esempio, l'etichetta Mobile Phone ha un possibile alias di Cell Phone.
-
Categorie - La categoria di etichette a cui appartiene l'etichetta rilevata. In questo esempio, si tratta di Tecnologia e informatica.
La risposta per le etichette relative a oggetti comuni include informazioni sul riquadro di delimitazione per la posizione dell'etichetta nell'immagine in input. Ad esempio, l'etichetta Persona dispone di una serie di istanze contenenti due riquadri di delimitazione che si riferiscono a due persone rilevate all'interno dell'immagine.
La risposta include anche gli attributi relativi a IMAGE_PROPERTIES. Gli attributi presentati dalla funzione IMAGE_PROPERTIES sono:
-
Qualità - Informazioni su nitidezza, luminosità e contrasto dell'immagine in ingresso, con un punteggio compreso tra 0 e 100. La qualità viene riportata per l'intera immagine e per lo sfondo e il primo piano dell'immagine, se disponibili. Tuttavia, il contrasto viene riportato solo per l'intera immagine, mentre la nitidezza e la luminosità vengono riportate anche per lo sfondo e il primo piano.
-
Colore dominante - Una serie di colori dominanti nell'immagine. Ogni colore dominante è descritto con un nome di colore semplificato, una tavolozza di colori CSS, valori RGB e un codice esadecimale.
-
Primo piano - Informazioni sui colori, la nitidezza e la luminosità dominanti del primo piano dell'immagine di input.
-
Sfondo - Informazioni sui colori, la nitidezza e la luminosità dominanti dello sfondo dell'immagine di input.
Quando GENERAL_LABELS e IMAGE_PROPERTIES vengono utilizzati insieme come parametri di input, Immagini Amazon Rekognition restituirà anche i colori dominanti degli oggetti con riquadri di delimitazione.
Il campo LabelModelVersion contiene il numero di versione del modello di rilevamento utilizzato da 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"
}
Quando si utilizza l' DetectLabels API, potrebbe essere necessario che la struttura di risposta imiti la precedente struttura di risposta dell'API, in cui sia le etichette primarie che gli alias erano contenuti nello stesso elenco.
Di seguito è riportato un esempio dell'attuale risposta dell'API di: DetectLabels
"Labels": [
{
"Name": "Mobile Phone",
"Confidence": 99.99717712402344,
"Instances": [],
"Parents": [
{
"Name": "Phone"
}
],
"Aliases": [
{
"Name": "Cell Phone"
}
]
}
]
L'esempio seguente mostra la risposta precedente dell'DetectLabelsAPI:
"Labels": [
{
"Name": "Mobile Phone",
"Confidence": 99.99717712402344,
"Instances": [],
"Parents": [
{
"Name": "Phone"
}
]
},
{
"Name": "Cell Phone",
"Confidence": 99.99717712402344,
"Instances": [],
"Parents": [
{
"Name": "Phone"
}
]
},
]
Se necessario, puoi trasformare la risposta corrente in modo che segua il formato della risposta precedente. È possibile utilizzare il seguente codice di esempio per trasformare la risposta API più recente nella precedente struttura di risposta dell'API:
- Python
-
Il seguente esempio di codice mostra come trasformare la risposta corrente dell' DetectLabels API. Nell'esempio di codice riportato di seguito, è possibile sostituire il valore di EXAMPLE_INFERENCE_OUTPUT con l'output di un'operazione eseguita. 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)
Di seguito è riportato un esempio della risposta trasformata:
#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"
]
}
]
}
