Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Erkennen von Labels in einem Bild
Sie können die DetectLabelsOperation verwenden, um Beschriftungen (Objekte und Konzepte) in einem Bild zu erkennen und Informationen über die Eigenschaften eines Bilds abzurufen. Zu den Bildeigenschaften gehören Attribute wie die Farbe des Vordergrunds und des Hintergrunds sowie die Schärfe, Helligkeit und der Kontrast des Bildes. Sie können nur die Labels in einem Bild, nur die Eigenschaften des Bildes oder beides abrufen. Ein Beispiel finden Sie unter Analysieren von Bildern, die in einem Amazon-S3-Bucket gespeichert sind.
In den folgenden Beispielen werden verschiedene AWS SDKs und der Aufruf AWS CLI DetectLabels to verwendet. Informationen über die Antwort auf die Operation DetectLabels finden Sie unter DetectLabels Antwort.
So erkennen Sie Labels in einem Bild
-
Wenn Sie dies noch nicht getan haben:
Erstellen oder aktualisieren Sie einen Benutzer mit AmazonRekognitionFullAccess- und AmazonS3ReadOnlyAccess-Berechtigungen. Weitere Informationen finden Sie unter Schritt 1: Einrichten eines AWS-Kontos und Erstellen eines Benutzers.
Installieren und konfigurieren Sie die AWS CLI und die AWS SDKs. Weitere Informationen finden Sie unter Schritt 2: Richten Sie die AWS CLI und AWS SDKs ein.
-
Laden Sie ein Bild mit einem oder mehreren Objekten wie Bäumen, Häusern und einem Boot auf Ihren S3-Bucket hoch. Das Bild muss entweder im JPG- oder PNG-Format vorliegen.
Weitere Anleitungen finden Sie unter Upload eines Objekts in Amazon S3 im Benutzerhandbuch für Amazon Simple Storage Service.
-
Verwenden Sie die folgenden Beispiele zum Aufrufen der DetectLabels-Operation.
- Java
-
Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben.
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
-
Dieses Beispiel zeigt die JSON-Ausgabe von der detect-labels-CLI-Operation an. Ersetzen Sie die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von profile-name mit dem Namen Ihres Entwicklerprofils.
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
Wenn Sie auf einem Windows-Gerät auf die CLI zugreifen, verwenden Sie doppelte Anführungszeichen anstelle von einfachen Anführungszeichen und maskieren Sie die inneren doppelten Anführungszeichen durch einen Backslash (d. h. \), um eventuell auftretende Parserfehler zu beheben. Sehen Sie sich zum Beispiel Folgendes an:
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
Dieses Beispiel zeigt die Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie in der main-Funktion die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bildes, die Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von profile_name in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.
#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
-
Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben.
//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
-
Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben.
# 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
-
Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von profile_name in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.
Wenn Sie TypeScript Definitionen verwenden, müssen Sie möglicherweise import AWS from 'aws-sdk' anstelle vonconst
AWS = require('aws-sdk'), verwenden, um das Programm mit Node.js auszuführen. Weitere Informationen finden Sie im AWS
-SDK für Javascript. Je nachdem, wie Sie Ihre Konfigurationen eingerichtet haben, müssen Sie möglicherweise auch Ihre Region mit AWS.config.update({region:region}); angeben.
// 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
-
Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie hier.
//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 Operationsanfrage
Die Eingabe in DetectLabel ist ein Bild. In dieser Beispiel-JSON-Eingabe wird das Quellbild aus einem Amazon-S3-Bucket geladen. MaxLabels gibt die maximale Anzahl der Labels an, die zurückzugeben sind. MinConfidence ist das minimale Vertrauen, das Amazon Rekognition Image in die Genauigkeit des erkannten Labels haben muss, damit es in der Antwort zurückgegeben wird.
Mit Eigenschaften können Sie ein oder mehrere Eigenschaften des Bilds angeben, die zurückgegeben werden sollen, sodass Sie GENERAL_LABELS und IMAGE_PROPERTIES auswählen können. Der Einschluss von GENERAL_LABELS wird die im Eingabebild erkannten Label zurückgeben, während Sie mit dem Einschluss von IMAGE_PROPERTIES auf Farbe und Qualität des Bildes zugreifen können.
Mit den Einstellungen können Sie die zurückgegebenen Artikel sowohl nach den GENERAL_LABELS- als auch nach den IMAGE_PROPERTIES-Merkmalen filtern. Für Label können Sie inklusive und exklusive Filter verwenden. Sie können auch nach labelspezifischen, individuellen Labels oder Nach-Label-Kategorien filtern:
-
LabelInclusionFilters - Ermöglicht es Ihnen, anzugeben, welche Labels in die Antwort aufgenommen werden sollen.
-
LabelExclusionFilters - Ermöglicht es Ihnen, anzugeben, welche Labels aus der Antwort ausgeschlossen werden sollen.
-
LabelCategoryInclusionFilters - Ermöglicht es Ihnen, anzugeben, welche Labelkategorien in die Antwort aufgenommen werden sollen.
-
LabelCategoryExclusionFilters - Ermöglicht es Ihnen, anzugeben, welche Labelkategorien aus der Antwort ausgeschlossen werden sollen.
Sie können je nach Bedarf auch inklusive und exklusive Filter kombinieren, wobei Sie einige Label oder Kategorien ausschließen und andere einbeziehen.
IMAGE_PROPERTIES beziehen sich auf die dominierenden Farben und Qualitätsmerkmale eines Bildes wie Schärfe, Helligkeit und Kontrast. Bei der Erkennung von IMAGE_PROPERTIES können Sie mithilfe des MaxDominantColors-Parameters die maximale Anzahl dominanter Farben angeben, die zurückgegeben werden sollen (Standard ist 10).
{
"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 Antwort
Die Antwort von DetectLabels ist ein Array der erkannten Labels in dem Bild und der Zuverlässigkeitswert, mit dem sie erkannt wurden.
Das folgende Beispiel ist eine Antwort von DetectLabels. Die folgende Beispielantwort enthält eine Vielzahl von Attributen, die für GENERAL_Label zurückgegeben wurden, darunter:
-
Name: Der Name des erkannten Labels. In diesem Beispiel wurde bei der Operation ein Objekt mit dem Label „Handy“ erkannt.
-
Zuverlässigkeit: Jedem Label ist ein Zuverlässigkeitswert, d. h. ein Zuverlässigkeitswert, zugeordnet. In diesem Beispiel lag die Zuverlässigkeit für das Label bei 99,36 %.
-
Übergeordnete Kategorien: Die Vorfahren-Labels für ein erkanntes Label. In diesem Beispiel hat das Label „Handy“ ein übergeordnetes Label namens „Telefon“.
-
Aliase: Informationen über mögliche Aliase für das Label. In diesem Beispiel hat das Label „Mobiltelefon“ das mögliche Alias „Handy“.
-
Kategorien: Die Labelkategorie, zu der das erkannte Label gehört. In diesem Beispiel handelt es sich um Technologie und Informatik.
Die Antwort für gängige Objektlabels enthält Informationen zum Begrenzungsrahmen für die Position des Labels auf dem Eingabebild. Beispiel: Das Label „Person“ ist ein Instances-Array mit zwei Begrenzungsrahmen. Dies sind die Positionen von zwei Personen, die im Bild erkannt wurden.
Die Antwort enthält auch Attribute zu IMAGE_PROPERTIES. Die Funktion IMAGE_PROPERTIES bietet folgende Attribute:
-
Qualität: Informationen über Schärfe, Helligkeit und Kontrast des Eingabebilds, bewertet zwischen 0 und 100. Die Qualität wird für das gesamte Bild sowie für den Hintergrund und Vordergrund des Bildes angegeben, sofern verfügbar. Der Kontrast wird jedoch nur für das gesamte Bild gemeldet, während Schärfe und Helligkeit auch für Hintergrund und Vordergrund gemeldet werden.
-
Dominante Farbe: Eine Reihe der dominanten Farben im Bild. Jede dominante Farbe wird mit einem vereinfachten Farbnamen, einer CSS-Farbpalette, RGB-Werten und einem Hex-Code beschrieben.
-
Vordergrund: Informationen über die dominanten Farben, Schärfe und Helligkeit des Vordergrunds des Eingabebilds.
-
Hintergrund: Informationen über die dominierenden Farben, Schärfe und Helligkeit des Hintergrunds des Eingabebilds.
Wenn GENERAL_LABELS und IMAGE_PROPERTIES zusammen als Eingabeparameter verwendet werden, gibt Amazon Rekognition Image auch die dominanten Farben von Objekten mit Begrenzungsrahmen zurück.
Das Feld LabelModelVersion enthält die Versionsnummer des von DetectLabels verwendeten Erkennungsmodells.
{
"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"
}
Wenn Sie die DetectLabels API verwenden, muss die Antwortstruktur möglicherweise die ältere API-Antwortstruktur nachahmen, bei der sowohl primäre Labels als auch Aliase in derselben Liste enthalten waren.
Im Folgenden finden Sie ein Beispiel für die aktuelle API-Antwort von: DetectLabels
"Labels": [
{
"Name": "Mobile Phone",
"Confidence": 99.99717712402344,
"Instances": [],
"Parents": [
{
"Name": "Phone"
}
],
"Aliases": [
{
"Name": "Cell Phone"
}
]
}
]
Das folgende Beispiel zeigt die vorherige Antwort der DetectLabelsAPI:
"Labels": [
{
"Name": "Mobile Phone",
"Confidence": 99.99717712402344,
"Instances": [],
"Parents": [
{
"Name": "Phone"
}
]
},
{
"Name": "Cell Phone",
"Confidence": 99.99717712402344,
"Instances": [],
"Parents": [
{
"Name": "Phone"
}
]
},
]
Bei Bedarf können Sie die aktuelle Antwort so transformieren, dass sie dem Format der älteren Antwort folgt. Sie können den folgenden Beispielcode verwenden, um die neueste API-Antwort in die vorherige API-Antwortstruktur umzuwandeln:
- Python
-
Das folgende Codebeispiel zeigt, wie die aktuelle Antwort von der DetectLabels API transformiert wird. Im folgenden Codebeispiel können Sie den Wert von EXAMPLE_INFERENCE_OUTPUT durch die Ausgabe einer DetectLabels Operation ersetzen, die Sie ausgeführt haben.
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)
Hier ist ein Beispiel für die transformierte Antwort:
#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"
]
}
]
}
