

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.

# Erkennung von Objekten und Konzepten
<a name="labels"></a>

Dieser Abschnitt enthält Informationen zur Erkennung von Labels in Bildern und Videos mit Amazon Rekognition Image und Amazon Rekognition Video. 

 Ein Label oder ein Tag ist ein Objekt oder ein Konzept (einschließlich Szenen und Aktionen), das in einem Bild oder Video anhand seines Inhalts gefunden wird. Ein Bild von Menschen an einem tropischen Strand kann zum Beispiel Etiketten wie Palme (Objekt), Strand (Szene), Laufen (Aktion) und Draußen (Konzept) enthalten. 

**Etiketten, die von Rekognition-Etikettenerkennungsoperationen unterstützt werden**
+ Um die neueste Liste der von Amazon Rekognition unterstützten Labels und Objektbegrenzungsrahmen herunterzuladen, klicken Sie [hier](samples/AmazonRekognitionLabels_v3.0.zip). 
+ Um die vorherige Liste der Labels und Objektbegrenzungsrahmen herunterzuladen, klicken Sie [hier](samples/AmazonRekognitionLabels_v2.0.zip). 

**Anmerkung**  
Amazon Rekognition macht binäre geschlechtsspezifische Vorhersagen (Mann, Frau, Mädchen usw.), die auf dem physischen Erscheinungsbild einer Person in einem bestimmten Bild basieren. Diese Art von Vorhersage dient nicht dazu, die Geschlechtsidentität einer Person zu kategorisieren, und Sie sollten Amazon Rekognition nicht verwenden, um eine solche Entscheidung zu treffen. Beispielsweise könnte ein männlicher Schauspieler, der für eine Rolle eine langhaarige Perücke und Ohrringe trägt, als weiblich eingestuft werden.  
Die Verwendung von Amazon Rekognition für binäre geschlechtsspezifische Vorhersagen eignet sich am besten für Anwendungsfälle, in denen aggregierte Statistiken zur Geschlechterverteilung analysiert werden müssen, ohne bestimmte Benutzer zu identifizieren. Zum Beispiel der Prozentsatz weiblicher Benutzer im Vergleich zu männlichen Benutzern auf einer Social-Media-Plattform.  
Wir raten davon ab, anhand von binären Geschlechtervoraussagen Entscheidungen zu treffen, durch sich auf die Rechte, Datenschutz oder Zugriff auf Services von Einzelpersonen auswirken.

Amazon Rekognition sendet Label in englischer Sprache zurück. Sie können [Amazon Translate](https://aws.amazon.com/translate/) verwenden, um englische Label in [andere Sprachen](https://docs.aws.amazon.com/translate/latest/dg/what-is.html#language-pairs) zu übersetzen.

Das folgende Diagramm zeigt die Reihenfolge der Anrufvorgänge, abhängig von Ihren Zielen für die Nutzung der Amazon Rekognition Image- oder Amazon Rekognition Video Video-Operationen: 



![\[Das Diagramm zeigt die Workflows zur Bild- und Videoanalyse mit der Verarbeitung von gespeicherten und gestreamten Videos.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/LabelDetectionWorkflow.png)


## Label-Antwortobjekte
<a name="labels-details"></a>

### Begrenzungsrahmen
<a name="labels-details-bbox"></a>

Amazon Rekognition Image und Amazon Rekognition Video können die Begrenzungsrahmen für gängige Objektlabels wie z. B. Personen, Fahrzeuge, Möbel, Bekleidung oder Haustiere zurückgeben. Für weniger gängige Objektlabels werden keine Informationen zum Begrenzungsrahmen zurückgegeben. Sie können die Begrenzungsrahmen verwenden, um die genaue Position von Objekten in einem Bild zu finden, Instanzen erkannter Objekte zu zählen oder die Größe eines Objekts mit Begrenzungsrahmen-Dimensionen zu messen. 

Zum Beispiel kann Amazon Rekognition Image im folgenden Bild die Anwesenheit einer Person, eines Skateboards, geparkter Autos und andere Informationen erkennen. Amazon Rekognition Image gibt auch den Begrenzungsrahmen für eine erkannte Person und andere erkannte Objekte wie Autos und Räder zurück. 

![\[Person, die auf einer Stadtstraße einen Skateboard-Stunt zwischen geparkten Autos macht.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/detect-scenes.jpg)


### Zuverlässigkeitswert
<a name="labels-details-image-conf-score"></a>

Amazon Rekognition Video und Amazon Rekognition Image geben in Prozent an, wie viel Zuverlässigkeit Amazon Rekognition in die Richtigkeit jedes erkannten Labels hat.

### Übergeordnete Kategorien
<a name="labels-details-parents"></a>

Amazon Rekognition Image und Amazon Rekognition Video verwenden eine hierarchische Taxonomie von Ahnen-Labels, um Label zu kategorisieren. Beispiel: Eine Person, die eine Straße überquert, könnte als *Fußgänger* erkannt werden. Das übergeordnete Label für *Fußgänger* ist *Person*. Beide diese Labels werden in der Antwort zurückgegeben. Alle Vorgängerlabels werden zurückgegeben. Jedes Label enthält eine Liste der übergeordneten Labels und andere Vorgängerlabels. Beispiel: Großeltern- und Urgroßeltern-Labels, sofern vorhanden. Sie können die übergeordneten Labels zum Erstellen von Gruppen zusammengehöriger Labels verwenden, und um Abfragen ähnlicher Labels in einem oder mehreren Bildern zuzulassen. Beispiel: Eine Abfrage für alle *Fahrzeuge* könnte ein Auto von einem Bild und ein Motorrad von einem anderen zurückgeben.

### Kategorien
<a name="labels-details-image-categories"></a>

Amazon Rekognition Image und Amazon Rekognition Video geben Informationen zu Labelkategorien zurück. Label sind Teil von Kategorien, in denen einzelne Label auf der Grundlage gemeinsamer Funktionen und Kontexte gruppiert werden, z. B. „Fahrzeuge und Autos“ und „Lebensmittel und Getränke“. Eine Labelkategorie kann eine Unterkategorie einer übergeordneten Kategorie sein. 

### Aliase
<a name="labels-details-image-aliases"></a>

Amazon Rekognition Image und Amazon Rekognition Video senden nicht nur Label sondern geben auch alle Aliase zurück, die mit dem Label verknüpft sind. Aliase sind Label mit derselben Bedeutung oder Label, die visuell mit dem zurückgesandten Hauptlabel austauschbar sind. Beispielsweise ist „Handy“ ein Alias für „Mobiltelefon“. 

In früheren Versionen gab Amazon Rekognition Image Aliase wie „Handy“ in derselben Liste von Hauptlabelnamen zurück, die „Mobiltelefon“ enthielten. Amazon Rekognition Image gibt jetzt „Handy“ in einem Feld mit dem Namen „Aliase“ und „Mobiltelefon“ in der Liste der Hauptlabelnamen zurück. Wenn Ihre Anwendung auf den Strukturen basiert, die von einer früheren Version von Rekognition zurückgegeben wurden, müssen Sie möglicherweise die aktuelle Antwort, die von den Bild- oder Videolabelerkennungsoperationen zurückgegeben wurde, in die vorherige Antwortstruktur umwandeln, in der alle Label und Aliase als Hauptlabel zurückgegeben werden.

Wenn Sie die aktuelle Antwort von der DetectLabels API (für die Erkennung von Etiketten in Bildern) in die vorherige Antwortstruktur umwandeln müssen, finden Sie das Codebeispiel unter. [Transformation der DetectLabels Antwort](labels-detect-labels-image.md#detectlabels-transform-response) 

Wenn Sie die aktuelle Antwort von der GetLabelDetection API (zur Erkennung von Bezeichnungen in gespeicherten Videos) in die vorherige Antwortstruktur umwandeln müssen, finden Sie das Codebeispiel unter[Transformation der Antwort GetLabelDetection](labels-detecting-labels-video.md#getlabeldetection-transform-response).

### Bildeigenschaften
<a name="labels-details-image-properties"></a>

Amazon Rekognition Image gibt Informationen zur Bildqualität (Schärfe, Helligkeit und Kontrast) für das gesamte Bild zurück. Schärfe und Helligkeit werden auch für den Vordergrund und den Hintergrund des Bildes zurückgegeben. Bildeigenschaften können auch verwendet werden, um dominante Farben des gesamten Bildes, des Vordergrunds, des Hintergrunds und von Objekten mit Begrenzungsrahmen zu erkennen.

![\[Ein Bild eines grünen Autos auf einer Stadtstraße, wobei das Auto von einem Begrenzungsrahmen umgeben ist.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/car_bb.png)


 Das Folgende ist ein Beispiel für die ImageProperties Daten, die in der Antwort auf eine DetectLabels Operation für das nachfolgende Bild enthalten sind:

![\[Tabelle mit dominanten Farben und Bildqualitätsmetriken für ein ganzes Bild, Vordergrund, Hintergrund und ein Beispielobjekt mit einem Begrenzungsrahmen.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/image_properties_table.png)


Bildeigenschaften sind für Amazon Rekognition Video nicht verfügbar.

### Modellversion
<a name="labels-details-image-model-version"></a>

Amazon Rekognition Image und Amazon Rekognition Video geben beide die Version des Label-Erkennungsmodells zurück, mit dem Labels in einem Bild oder einem gespeicherten Video erkannt wurden. 

### Einschluss- und Ausschlussfilter
<a name="labels-details-filters"></a>

Sie können die Ergebnisse filtern, die von Amazon-Rekognition-Image- und Amazon-Rekognition-Video-Labelerkennungsoperationen zurückgegeben werden. Filtern Sie die Ergebnisse, indem Sie Filterkriterien für Label und Kategorien angeben. Labelfilter können inklusiv oder exklusiv sein. 

Weitere Informationen zur Filterung der mit `DetectLabels` erzielten Ergebnisse finden Sie unter [Erkennen von Labels in einem Bild](labels-detect-labels-image.md).

Weitere Informationen zur Filterung der durch `GetLabelDetection` erzielten Ergebnisse finden Sie unter [Erkennen von Labels in einem Video](labels-detecting-labels-video.md).

### Ergebnisse sortieren und aggregieren
<a name="labels-details-sorting-aggregating"></a>

Die Ergebnisse bestimmter Amazon-Rekognition-Video-Operationen können nach Zeitstempeln und Videosegmenten sortiert und aggregiert werden. Beim Abrufen der Ergebnisse eines Auftrags zur Labelerkennung oder Inhaltsmoderation können Sie mit `GetLabelDetection` bzw. `GetContentModeration` die `SortBy`- und `AggregateBy`-Argumente verwenden, um anzugeben, wie Ihre Ergebnisse zurückgegeben werden sollen. Sie können `SortBy` mit `TIMESTAMP` oder `NAME` (Labelnamen) und `TIMESTAMPS` oder `SEGMENTS` mit dem AggregateBy Argument verwenden.

# Erkennen von Labels in einem Bild
<a name="labels-detect-labels-image"></a>

Sie können die [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)Operation 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](images-s3.md).

In den folgenden Beispielen werden die AWS SDKs Befehle various und AWS CLI to verwendet`DetectLabels`. Informationen über die Antwort auf die Operation `DetectLabels` finden Sie unter [DetectLabels Antwort](#detectlabels-response).

**So erkennen Sie Labels in einem Bild**

1. Wenn Sie dies noch nicht getan haben:

   1. 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](setting-up.md#setting-up-iam).

   1. Installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 2: Richten Sie das AWS CLI und ein AWS SDKs](setup-awscli-sdk.md).

1. 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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.

1. 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. \$1), 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 = 'amzn-s3-demo-bucket'
       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 = "amzn-s3-demo-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 von`const AWS = require('aws-sdk')`, verwenden, um das Programm mit Node.js auszuführen. Weitere Informationen finden Sie im [AWS -SDK für Javascript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/). 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DetectLabels.java).

   ```
   //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
<a name="detectlabels-request"></a>

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
<a name="detectlabels-response"></a>

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\$1Label 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\$1PROPERTIES. Die Funktion IMAGE\$1PROPERTIES 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\$1LABELS und IMAGE\$1PROPERTIES 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"
}
```

## Transformation der DetectLabels Antwort
<a name="detectlabels-transform-response"></a>

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](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)

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

Das folgende Beispiel zeigt die vorherige Antwort der [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API:

```
"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\$1INFERENCE\$1OUTPUT* 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"
            ]
        }
    ]
}
```

------

# Erkennen von Labels in einem Video
<a name="labels-detecting-labels-video"></a>

Amazon Rekognition Video kann Label (Objekte und Konzepte) und den Zeitpunkt, zu dem ein Label erkannt wird, in einem Video erkennen. Ein SDK-Codebeispiel finden Sie unter [Analysieren eines in einem Amazon S3-Bucket gespeicherten Videos mit Java oder Python (SDK)](video-analyzing-with-sqs.md). Ein AWS CLI Beispiel finden Sie unter[Analysieren eines Videos mit dem AWS Command Line Interface](video-cli-commands.md).

Die Amazon-Rekognition-Video-Labelerkennung ist eine asynchrone Operation. Rufen Sie an, um die Erkennung von Etiketten in einem Video zu starten [StartLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartlabelDetection.html). 

Das Amazon-Simple-Notification-Service-Thema, zu dem Amazon Rekognition Video die Ergebnisse der Objekterkennung und den Abschlussstatus einer Videoanalyse-Operation veröffentlicht. Wenn die Videoanalyse erfolgreich ist, rufen Sie [GetLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetLabelDetection.html) auf, um die erkannten Labels zu erhalten. Informationen zum Aufruf von API-Operationen der Videoanalyse finden Sie unter [Amazon-Rekognition-Video-Operationen aufrufen](api-video.md). 

## StartLabelDetection Anfrage
<a name="getlabeldetection-operation-request"></a>

Das folgende Beispiel ist eine Anforderung für die `StartLabelDetection`-Operation. Sie stellen für die `StartLabelDetection`-Operation ein Video bereit, das in einem Amazon-S3-Bucket gespeichert ist. In der JSON-Beispielanforderung werden der Amazon-S3-Bucket und der Videoname zusammen mit `MinConfidence`, `Features`, `Settings` und `NotificationChannel` angegeben.

`MinConfidence` ist das Mindestvertrauen, das Amazon Rekognition Video in die Genauigkeit des erkannten Labels oder eines Instance-Begrenzungsrahmens (falls erkannt) haben muss, damit es in der Antwort zurückgegeben wird.

Mit `Features` können Sie angeben, dass GENERAL\$1LABELS als Teil der Antwort zurückgegeben werden soll.

Mit `Settings` können Sie die zurückgegebenen Artikel nach GENERAL\$1LABELS 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` – Wird verwendet, um anzugeben, welche Label in der Antwort enthalten sein sollen 
+ `LabelExclusionFilters` – Wird verwendet, um anzugeben, welche Label aus der Antwort ausgeschlossen werden sollen.
+ `LabelCategoryInclusionFilters` – Wird verwendet, um anzugeben, welche Labelkategorien in die Antwort aufgenommen werden sollen.
+ `LabelCategoryExclusionFilters` – Wird verwendet, um 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.

`NotificationChannel` ist der ARN des Amazon-SNS-Themas, für das Amazon Rekognition Video den Abschlussstatus des Labelerkennungsvorgangs veröffentlichen soll. Wenn Sie die `AmazonRekognitionServiceRole`-Berechtigungsrichtlinie verwenden, muss das Amazon-SNS-Thema einen Themennamen haben, der mit Rekognition beginnt.

Im Folgenden finden Sie eine `StartLabelDetection`-Beispielanforderung in JSON-Form, einschließlich Filtern:

```
{
    "ClientRequestToken": "5a6e690e-c750-460a-9d59-c992e0ec8638",
    "JobTag": "5a6e690e-c750-460a-9d59-c992e0ec8638",
    "Video": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "video.mp4" 
         } 
     }, 
     "Features": ["GENERAL_LABELS"],
     "MinConfidence": 75,
     "Settings": {
         "GeneralLabels": {
             "LabelInclusionFilters": ["Cat", "Dog"],
             "LabelExclusionFilters": ["Tiger"],
             "LabelCategoryInclusionFilters": ["Animals and Pets"],
             "LabelCategoryExclusionFilters": ["Popular Landmark"] 
         }
     },
     "NotificationChannel": {
         "RoleArn": "arn:aws:iam::012345678910:role/SNSAccessRole",
         "SNSTopicArn": "arn:aws:sns:us-east-1:012345678910:notification-topic",
     }
}
```

## GetLabelDetection Antwort auf die Operation
<a name="getlabeldetection-operation-response"></a>

`GetLabelDetection` gibt ein Array (`Labels`) zurück, das Informationen über die erkannten Labels im Video enthält. Das Array kann entweder nach Zeit oder nach dem Label sortiert werden, das bei der Angabe des `SortBy`-Parameters erkannt wurde. Mithilfe des Parameters können Sie auch auswählen, wie Antwortelemente mit `AggregateBy` aggregiert werden. 

Nachfolgend finden Sie ein Beispiel einer JSON-Antwort von `GetLabelDetection`. In der Antwort ist Folgendes zu beachten:
+ **Sortierreihenfolge** – Das Array der zurückgegebenen Labels wird nach der Zeit sortiert. Um nach dem Label zu sortieren, geben Sie `NAME` im Eingabeparameter `SortBy` für `GetLabelDetection` an. Wenn das Label mehrfach im Video erscheint, gibt es mehrere Instanzen des Elements ([LabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_LabelDetection.html)). Die Standardsortierreihenfolge ist `TIMESTAMP`, die sekundäre Sortierreihenfolge ist `NAME`.
+ **Label-Informationen** – Das `LabelDetection`-Arrayelement enthält ein ([Label](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Label.html))-Objekt, das wiederum den Namen des Labels und das Vertrauen, das Amazon Rekognition in die Genauigkeit des erkannten Labels hat, enthält. Ein `Label`-Objekt enthält auch eine hierarchische Taxonomie der Labels und Begrenzungsrahmen-Informationen für gängige Labels. `Timestamp` ist die Zeit, zu der das Label erkannt wurde, definiert als die Anzahl der seit dem Start des Videos verstrichenen Millisekunden. 

  Informationen zu allen Kategorien oder Aliasnamen, die einem Label zugeordnet sind, werden ebenfalls zurückgegeben. Bei nach Video `SEGMENTS` aggregierten Ergebnissen werden die `StartTimestampMillis`-, `EndTimestampMillis`- und `DurationMillis`-Strukturen zurückgegeben, die jeweils die Startzeit, die Endzeit und die Dauer eines Segments definieren.
+ **Aggregation**: Gibt an, wie Ergebnisse aggregiert werden, wenn sie zurückgegeben werden. Standardmäßig wird nach `TIMESTAMPS` aggregiert. Sie können sich auch für die Aggregation nach `SEGMENTS` entscheiden, wodurch die Ergebnisse über ein Zeitfenster aggregiert werden. Bei der Aggregation nach `SEGMENTS` werden Informationen über erkannte Instances mit Begrenzungsrahmen nicht zurückgegeben. Es werden nur Label zurückgegeben, die während der Segmente erkannt wurden.
+ **Seiteninformationen** – Das Beispiel zeigt eine Seite mit Informationen der Label-Erkennung. Sie können festlegen, wie viele `LabelDetection`-Objekte zurückgegeben werden sollen, durch den Eingabeparameter `MaxResults` von `GetLabelDetection`. Wenn mehr Ergebnisse als `MaxResults` vorhanden sind, gibt `GetLabelDetection` einen Token zurück (`NextToken`), der dazu verwendet wird, die nächste Seite mit Ergebnissen zu erhalten. Weitere Informationen finden Sie unter [Analyseergebnisse von Amazon Rekognition Video abrufen](api-video.md#api-video-get).
+ **Video-Informationen** – Die Antwort enthält Informationen über das Videoformat (`VideoMetadata`) in jeder Seite mit Informationen, die von `GetLabelDetection` zurückgegeben werden.

Im Folgenden finden Sie eine GetLabelDetection Beispielantwort in JSON-Form mit Aggregation durch TIMESTAMPS:

```
{  
    "JobStatus": "SUCCEEDED",
    "LabelModelVersion": "3.0",
    "Labels": [
        {
            "Timestamp": 1000,
            "Label": {
                "Name": "Car",
                "Categories": [
                  {
                    "Name": "Vehicles and Automotive"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Automobile"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875, // Classification confidence
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567         
                        },  
                        "Confidence": 99.9364013671875 // Detection confidence     
                    }    
                ]
            }
        },
        {
            "Timestamp": 1000,
            "Label": {
                "Name": "Cup",
                "Categories": [
                  {
                    "Name": "Kitchen and Dining"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Mug"
                  }
                ],
                "Parents": [],
                "Confidence": 99.9364013671875, // Classification confidence
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567         
                        },  
                        "Confidence": 99.9364013671875 // Detection confidence     
                    }    
                ]
            }
        },
        {
            "Timestamp": 2000,
            "Label": {
                "Name": "Kangaroo",
                "Categories": [
                  {
                    "Name": "Animals and Pets"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Wallaby"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Mammal"
                  }
                ],
                "Confidence": 99.9364013671875,  
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567,
                        },  
                        "Confidence": 99.9364013671875    
                    }    
                ]
            }
        },
        {
            "Timestamp": 4000,
            "Label": {
                "Name": "Bicycle",
                "Categories": [
                  {
                    "Name": "Hobbies and Interests"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Bike"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875,
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567         
                        },  
                        "Confidence": 99.9364013671875     
                    }    
                ]
            }
        }
    ],
    "VideoMetadata": {
        "ColorRange": "FULL",
        "DurationMillis": 5000,
        "Format": "MP4",
        "FrameWidth": 1280,
        "FrameHeight": 720,
        "FrameRate": 24
    }
}
```

Im Folgenden finden Sie eine GetLabelDetection Beispielantwort in JSON-Form mit Aggregation nach SEGMENTEN:

```
{  
    "JobStatus": "SUCCEEDED",
    "LabelModelVersion": "3.0",
    "Labels": [ 
        {
            "StartTimestampMillis": 225,
            "EndTimestampMillis": 3578,
            "DurationMillis": 3353,
            "Label": {
                "Name": "Car",
                "Categories": [
                  {
                    "Name": "Vehicles and Automotive"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Automobile"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875 // Maximum confidence score for Segment mode
            }
        },
        {
            "StartTimestampMillis": 7578,
            "EndTimestampMillis": 12371,
            "DurationMillis": 4793,
            "Label": {
                "Name": "Kangaroo",
                "Categories": [
                  {
                    "Name": "Animals and Pets"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Wallaby"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Mammal"
                  }
                ],
                "Confidence": 99.9364013671875
            }
        },
        {
            "StartTimestampMillis": 22225,
            "EndTimestampMillis": 22578,
            "DurationMillis": 2353,
            "Label": {
                "Name": "Bicycle",
                "Categories": [
                  {
                    "Name": "Hobbies and Interests"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Bike"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875
            }
        }
    ],
    "VideoMetadata": {
        "ColorRange": "FULL",
        "DurationMillis": 5000,
        "Format": "MP4",
        "FrameWidth": 1280,
        "FrameHeight": 720,
        "FrameRate": 24
    }
}
```

## Transformation der Antwort GetLabelDetection
<a name="getlabeldetection-transform-response"></a>

Beim Abrufen von Ergebnissen mit der GetLabelDetection API-Operation muss die Antwortstruktur möglicherweise die ältere API-Antwortstruktur nachahmen, bei der sowohl primäre Labels als auch Aliase in derselben Liste enthalten waren.

Die JSON-Beispielantwort aus dem vorherigen Abschnitt zeigt die aktuelle Form der API-Antwort von. GetLabelDetection

Das folgende Beispiel zeigt die vorherige Antwort der GetLabelDetection API: 

```
{
    "Labels": [
        {
            "Timestamp": 0,
            "Label": {
                "Instances": [],
                "Confidence": 60.51791763305664,
                "Parents": [],
                "Name": "Leaf"
            }
        },
        {
            "Timestamp": 0,
            "Label": {
                "Instances": [],
                "Confidence": 99.53411102294922,
                "Parents": [],
                "Name": "Human"
            }
        },
        {
            "Timestamp": 0,
            "Label": {
                "Instances": [
                    {
                        "BoundingBox": {
                            "Width": 0.11109819263219833,
                            "Top": 0.08098889887332916,
                            "Left": 0.8881205320358276,
                            "Height": 0.9073750972747803
                        },
                        "Confidence": 99.5831298828125
                    },
                    {
                        "BoundingBox": {
                            "Width": 0.1268676072359085,
                            "Top": 0.14018426835536957,
                            "Left": 0.0003282368124928324,
                            "Height": 0.7993982434272766
                        },
                        "Confidence": 99.46029663085938
                    }
                ],
                "Confidence": 99.63411102294922,
                "Parents": [],
                "Name": "Person"
            }
        },
        .
        .   
        .

        {
            "Timestamp": 166,
            "Label": {
                "Instances": [],
                "Confidence": 73.6471176147461,
                "Parents": [
                    {
                        "Name": "Clothing"
                    }
                ],
                "Name": "Sleeve"
            }
        }
        
    ],
    "LabelModelVersion": "2.0",
    "JobStatus": "SUCCEEDED",
    "VideoMetadata": {
        "Format": "QuickTime / MOV",
        "FrameRate": 23.976024627685547,
        "Codec": "h264",
        "DurationMillis": 5005,
        "FrameHeight": 674,
        "FrameWidth": 1280
    }
}
```

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: 

```
from copy import deepcopy

VIDEO_LABEL_KEY = "Labels"
LABEL_KEY = "Label"
ALIASES_KEY = "Aliases"
INSTANCE_KEY = "Instances"
NAME_KEY = "Name"

#Latest API response sample for AggregatedBy SEGMENTS
EXAMPLE_SEGMENT_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label":{
                "Name": "Person",
                "Confidence": 97.530106,
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
            "StartTimestampMillis": 0,
            "EndTimestampMillis": 500666,
            "DurationMillis": 500666
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],

            },
            "StartTimestampMillis": 6400,
            "EndTimestampMillis": 8200,
            "DurationMillis": 1800
        },
    ]
}

#Output example after the transformation for AggregatedBy SEGMENTS
EXPECTED_EXPANDED_SEGMENT_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label":{
                "Name": "Person",
                "Confidence": 97.530106,
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
            "StartTimestampMillis": 0,
            "EndTimestampMillis": 500666,
            "DurationMillis": 500666
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],

            },
            "StartTimestampMillis": 6400,
            "EndTimestampMillis": 8200,
            "DurationMillis": 1800
        },
        {
            "Timestamp": 0,
            "Label":{
                "Name": "Human",
                "Confidence": 97.530106,
                "Parents": [],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
            "StartTimestampMillis": 0,
            "EndTimestampMillis": 500666,
            "DurationMillis": 500666
        },
    ]
}

#Latest API response sample for AggregatedBy TIMESTAMPS
EXAMPLE_TIMESTAMP_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label": {
                "Name": "Person",
                "Confidence": 97.530106,
                "Instances": [
                    {
                        "BoundingBox": {
                            "Height": 0.1549897,
                            "Width": 0.07747964,
                            "Top": 0.50858885,
                            "Left": 0.00018205095
                        },
                        "Confidence": 97.530106
                    },
                ],
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Instances": [],
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],
            },
        },
    ]
}

#Output example after the transformation for AggregatedBy TIMESTAMPS
EXPECTED_EXPANDED_TIMESTAMP_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label": {
                "Name": "Person",
                "Confidence": 97.530106,
                "Instances": [
                    {
                        "BoundingBox": {
                            "Height": 0.1549897,
                            "Width": 0.07747964,
                            "Top": 0.50858885,
                            "Left": 0.00018205095
                        },
                        "Confidence": 97.530106
                    },
                ],
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Instances": [],
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],
            },
        },
        {
            "Timestamp": 0,
            "Label": {
                "Name": "Human",
                "Confidence": 97.530106,
                "Parents": [],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
        },
    ]
}

def expand_aliases(inferenceOutputsWithAliases):

    if VIDEO_LABEL_KEY in inferenceOutputsWithAliases:
        expandInferenceOutputs = []
        for segmentLabelDict in inferenceOutputsWithAliases[VIDEO_LABEL_KEY]:
            primaryLabelDict = segmentLabelDict[LABEL_KEY]
            if ALIASES_KEY in primaryLabelDict:
                for alias in primaryLabelDict[ALIASES_KEY]:
                    aliasLabelDict = deepcopy(segmentLabelDict)
                    aliasLabelDict[LABEL_KEY][NAME_KEY] = alias[NAME_KEY]
                    del aliasLabelDict[LABEL_KEY][ALIASES_KEY]
                    if INSTANCE_KEY in aliasLabelDict[LABEL_KEY]:
                        del aliasLabelDict[LABEL_KEY][INSTANCE_KEY]
                    expandInferenceOutputs.append(aliasLabelDict)

        inferenceOutputsWithAliases[VIDEO_LABEL_KEY].extend(expandInferenceOutputs)

    return inferenceOutputsWithAliases


if __name__ == "__main__":

    segmentOutputWithExpandAliases = expand_aliases(EXAMPLE_SEGMENT_OUTPUT)
    assert segmentOutputWithExpandAliases == EXPECTED_EXPANDED_SEGMENT_OUTPUT

    timestampOutputWithExpandAliases = expand_aliases(EXAMPLE_TIMESTAMP_OUTPUT)
    assert timestampOutputWithExpandAliases == EXPECTED_EXPANDED_TIMESTAMP_OUTPUT
```

# Erkennung von Labels in Streaming-Videoereignissen
<a name="streaming-video-detect-labels"></a>

Sie können Amazon Rekognition Video verwenden, um Label in Streaming-Videos zu erkennen. Dazu erstellen Sie einen Stream-Prozessor ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)), um die Analyse von Streaming-Videos zu starten und zu verwalten. 

Amazon Rekognition Video verwendet Amazon Kinesis Video Streams, um einen Videostrom zu empfangen und zu verarbeiten. Wenn Sie den Stromprozessor erstellen, wählen Sie aus, was der Stromprozessor erkennen soll. Sie können zwischen Personen, Paketen und Haustieren oder Personen und Paketen wählen. Das Analyseergebnis wird in Ihrem Amazon-S3-Bucket und in Amazon-SNS-Benachrichtigungen ausgegeben. Beachten Sie, dass Amazon Rekognition Video die Anwesenheit einer Person im Video erkennt, aber nicht erkennt, ob es sich bei der Person um eine bestimmte Person handelt. Informationen zur Suche nach einem Gesicht aus einer Sammlung in einem Streaming-Video finden Sie unter [Suchen nach Gesichtern in einer Sammlung im Streaming-Video](collections-streaming.md). 

Um Amazon Rekognition Video mit Streaming-Video zu verwenden, benötigt Ihre Anwendung Folgendes:
+ Ein Kinesis-Videostrom zum Senden von Streaming-Videos an Amazon Rekognition Video. Weitere Informationen Sie im [Entwicklerleitfaden für Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Einen Amazon-Rekognition-Video-Stromprozessor zur Verwaltung der Analyse des Streaming-Videos. Weitere Informationen finden Sie unter [Überblick über den Betrieb des Amazon-Rekognition-Video-Stromprozessors](streaming-video.md#using-rekognition-video-stream-processor).
+ Ein Amazon-S3-Bucket Amazon Rekognition Video veröffentlicht Sitzungsausgaben im S3-Bucket. Die Ausgabe umfasst den Bildrahmen, in dem eine Person oder ein Objekt von Interesse zum ersten Mal erkannt wurde. Sie müssen Eigentümer des S3-Buckets sein.
+ Ein Amazon SNS SNS-Thema, zu dem Amazon Rekognition Video Smart Alerts und eine end-of-session Zusammenfassung veröffentlicht.

**Topics**
+ [Einrichtung Ihrer Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen](streaming-labels-setting-up.md)
+ [Rufen Sie Operationen zur Erkennung von Bezeichnungen für Streaming-Videoereignisse auf](streaming-labels-detection.md)

# Einrichtung Ihrer Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen
<a name="streaming-labels-setting-up"></a>

 In den folgenden Verfahren werden die Schritte beschrieben, die Sie ergreifen, um den Kinesis-Videostrom und andere Ressourcen bereitzustellen, die zur Erkennung von Labels in einem Streaming-Video verwendet werden.

## Voraussetzungen
<a name="streaming-video-prerequisites"></a>

Um dieses Verfahren ausführen zu können, AWS SDK für Java muss es installiert sein. Weitere Informationen finden Sie unter [Erste Schritte mit Amazon Rekognition](getting-started.md). Das AWS -Konto, das Sie verwenden, benötigt Zugriffsberechtigungen für die Amazon-Rekognition-API. Weitere Informationen finden Sie unter [Von Amazon Rekognition definierte Aktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) im *IAM-Benutzerhandbuch*. 

**So erkennen Sie Labels in einem Videostrom (AWS-SDK)**

1. Erstellen Sie einen Amazon-S3-Bucket. Notieren Sie den Bucket-Namen und alle Schlüsselpräfixe, die Sie verwenden möchten. Sie benötigen diese Informationen später.

1. Erstellen Sie ein Amazon-SNS-Thema. Sie können damit Benachrichtigungen erhalten, wenn ein Objekt von Interesse zum ersten Mal im Videostrom entdeckt wird. Notieren Sie sich den Amazon-Ressourcennamen (ARN) für das Thema. Weitere Informationen finden Sie unter [Erstellen eines Amazon-SNS-Themas](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html) im Amazon-SNS-Entwicklerhandbuch.

1. Richten Sie ein Endpunkt-Abonnement für ein Amazon-SNS-Thema ein. Weitere Informationen finden Sie unter [Amazon-SNS-Thema abonnieren](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) im Amazon-SNS-Entwicklerhandbuch.

1. [Erstellen Sie einen Kinesis-Videostrom](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) und notieren Sie sich den Amazon-Ressourcennamen (ARN) des Streams.

1. Falls Sie dies noch nicht getan haben, erstellen Sie eine IAM-Servicerolle, um Amazon Rekognition Video Zugriff auf Ihre Kinesis-Videoströme, Ihren S3-Bucket und Ihr Amazon-SNS-Thema zu gewähren. Weitere Informationen finden Sie unter [Zugriff für Stromprozessoren zur Labelerkennung gewähren](#streaming-labels-giving-access).

Anschließend können Sie [den Label-Erkennungs-Stromprozessor erstellen](streaming-labels-detection.md#streaming-video-create-labels-stream-processor) und den [Stromprozessor mit dem von Ihnen ausgewählten Stromprozessornamen starten](streaming-labels-detection.md#streaming-video-start-labels-stream-processor).

**Anmerkung**  
Starten Sie den Stromprozessor erst, nachdem Sie sich vergewissert haben, dass Sie Medien in den Kinesis-Videostrom aufnehmen können. 

## Ausrichtung und Einrichtung der Kamera
<a name="streaming-labels-camera-setup"></a>

Amazon Rekognition Video Streaming Video Events unterstützt alle Kameras, die von Kinesis Video Streams unterstützt werden. Für optimale Ergebnisse empfehlen wir, die Kamera zwischen 0 und 45 Grad über dem Boden aufzustellen. Die Kamera muss sich in ihrer kanonischen, aufrechten Position befinden. Wenn sich beispielsweise eine Person im Bild befindet, sollte die Person vertikal ausgerichtet sein und der Kopf der Person sollte höher im Bild stehen als die Füße.

## Zugriff für Stromprozessoren zur Labelerkennung gewähren
<a name="streaming-labels-giving-access"></a>

Sie verwenden eine AWS Identity and Access Management (IAM) -Servicerolle, um Amazon Rekognition Video Lesezugriff auf Kinesis-Videostreams zu gewähren. Verwenden Sie dazu IAM-Rollen, um Amazon Rekognition Video Zugriff auf Ihren Amazon-S3-Bucket und auf ein Amazon-SNS-Thema zu gewähren.

Sie können eine Berechtigungsrichtlinie erstellen, die Amazon Rekognition Video den Zugriff auf ein vorhandenes Amazon-SNS-Thema, einen Amazon-S3-Bucket und einen Kinesis-Videostrom ermöglicht. Ein step-by-step Verfahren mit dem finden Sie unter. AWS CLI[AWS CLI Befehle zum Einrichten einer IAM-Rolle für die Labelerkennung](#streaming-labels-giving-access-cli) 

**Um Amazon Rekognition Video Zugriff auf Ressourcen für die Labelerkennung zu gewähren**

1. [ Erstellen Sie mit dem IAM JSON Policy Editor](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) eine neue Berechtigungsrichtlinie und verwenden Sie die folgende Richtlinie. Ersetzen Sie `kvs-stream-name` durch den Namen des Kinesis-Videostroms, `topicarn` durch den Amazon-Ressourcennamen (ARN) des Amazon-SNS-Themas, das Sie verwenden möchten, und `bucket-name` durch den Namen des Amazon-S3-Buckets.

1. [Erstellen Sie ein IAM-Servicerolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console) oder aktualisieren Sie eine bestehende IAM-Servicerolle. Verwenden Sie die folgenden Informationen, um die IAM-Servicerolle zu erstellen:

   1. Wählen Sie **Rekognition** als Servicenamen.

   1. Wählen Sie **Rekognition** für den Anwendungsfall der Service-Rolle.

   1. Fügen Sie die Berechtigungsrichtlinie hinzu, die Sie in Schritt 1 erstellt haben.

1. Notieren Sie den ARN der Service-Rolle. Sie benötigen sie, um den Stromprozessor zu erstellen, bevor Sie Videoanalysevorgänge durchführen.

1. (Optional) Wenn Sie Ihren eigenen AWS KMS Schlüssel verwenden, um an Ihren S3-Bucket gesendete Daten zu verschlüsseln, müssen Sie die folgende Anweisung mit der IAM-Rolle hinzufügen. (Dies ist die IAM-Rolle, die Sie für die Schlüsselrichtlinie erstellt haben. Sie entspricht dem kundenverwalteten Schlüssel, den Sie verwenden möchten.)

   ```
       
               {
                          "Sid": "Allow use of the key by label detection Role",
                          "Effect": "Allow",
                          "Principal": {
                              "AWS": "arn:aws:iam:::role/REPLACE_WITH_LABEL_DETECTION_ROLE_CREATED"
                          },
                          "Action": [
                              "kms:Decrypt",
                              "kms:GenerateDataKey*"
                          ],
                          "Resource": "*"
               }
   ```

## AWS CLI Befehle zum Einrichten einer IAM-Rolle für die Labelerkennung
<a name="streaming-labels-giving-access-cli"></a>

Falls Sie dies noch nicht getan haben, richten Sie das AWS CLI mit Ihren Anmeldeinformationen ein und konfigurieren Sie es.

Geben Sie die folgenden Befehle in die ein AWS CLI , um eine IAM-Rolle mit den erforderlichen Berechtigungen für die Labelerkennung einzurichten.

1. `export IAM_ROLE_NAME=labels-test-role`

1. `export AWS_REGION=us-east-1`

1. Erstellen Sie eine Richtliniendatei für Vertrauensbeziehungen (z. B.. assume-role-rekognition json) mit dem folgenden Inhalt.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "",
         "Effect": "Allow",
         "Principal": {
           "Service": "rekognition.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

1. `aws iam create-role --role-name $IAM_ROLE_NAME --assume-role-policy-document file://path-to-assume-role-rekognition.json --region $AWS_REGION`

1. `aws iam attach-role-policy --role-name $IAM_ROLE_NAME --policy-arn "arn:aws:iam::aws:policy/service-role/AmazonRekognitionServiceRole" --region $AWS_REGION`

1. Wenn der Name Ihres SNS-Themas, mit dem Sie Benachrichtigungen erhalten möchten, nicht mit dem Präfix "AmazonRekognition" beginnt, fügen Sie die folgende Richtlinie hinzu:

   `aws iam attach-role-policy --role-name $IAM_ROLE_NAME --policy-arn "arn:aws:iam::aws:policy/AmazonSNSFullAccess" --region $AWS_REGION`

1. Wenn Sie Ihren eigenen AWS-KMS-Schlüssel verwenden, um Daten zu verschlüsseln, die an Ihren Amazon-S3-Bucket gesendet werden, aktualisieren Sie die Schlüsselrichtlinie des kundenverwalteten Schlüssels, den Sie verwenden möchten.

   1. Erstellen Sie eine Datei kms\$1key\$1policy.json, die den folgenden Inhalt enthält:

      ```
      {
      "Sid": "Allow use of the key by label detection Role",
      "Effect": "Allow",
      "Principal": {
      "AWS": "arn:aws:iam:::role/REPLACE_WITH_IAM_ROLE_NAME_CREATED"
      },
      "Action": [
      "kms:Encrypt",
      "kms:GenerateDataKey*"
      ],
      "Resource": "*"
      }
      ```

   1. `export KMS_KEY_ID=labels-kms-key-id`. Ersetzen Sie KMS\$1KEY\$1ID durch die KMS-Schlüssel-ID, die Sie erstellt haben.

   1. `aws kms put-key-policy --policy-name default --key-id $KMS_KEY_ID --policy file://path-to-kms-key-policy.json`

# Rufen Sie Operationen zur Erkennung von Bezeichnungen für Streaming-Videoereignisse auf
<a name="streaming-labels-detection"></a>

Amazon Rekognition Video kann Personen oder relevante Objekte in einem Streaming-Video erkennen und Sie benachrichtigen, wenn sie erkannt werden. Wenn Sie einen Stromprozessor zur Labelerkennung erstellen, wählen Sie aus, welche Labels Amazon Rekognition Video erkennen soll. Das können Personen, Pakete und Haustiere sein, oder Personen, Pakete und Haustiere. Wählen Sie nur die spezifischen Label aus, die Sie erkennen möchten. Auf diese Weise erstellen nur die relevanten Label Benachrichtigungen. Sie können Optionen konfigurieren, um festzulegen, wann Videoinformationen gespeichert werden sollen, und dann weitere Verarbeitungsschritte auf der Grundlage der im Frame erkannten Label durchführen.

Nachdem Sie Ihre Ressourcen eingerichtet haben, gehen Sie wie folgt vor, um Label in einem Streaming-Video zu erkennen:

1. Erstellen Sie den Stromprozessor

1. Starten Sie den Stromprozessor

1. Wenn ein Objekt von Interesse erkannt wird, erhalten Sie eine Amazon-SNS-Benachrichtigung für das erste Auftreten jedes Objekts von Interesse.

1. Der Stromprozessor stoppt, wenn die unter `MaxDurationInSeconds` angegebene Zeit abgelaufen ist.

1. Sie erhalten eine abschließende Amazon-SNS-Benachrichtigung mit einer Zusammenfassung des Ereignisses.

1. Amazon Rekognition Video veröffentlicht eine detaillierte Sitzungszusammenfassung in Ihrem S3-Bucket.

**Topics**
+ [Erstellen des Amazon-Rekognition-Video-Stromprozessors zur Labelerkennung](#streaming-video-create-labels-stream-processor)
+ [Starten des Amazon-Rekognition-Video-Stromprozessors zur Labelerkennung](#streaming-video-start-labels-stream-processor)
+ [Analysieren der Ergebnisse der Labelerkennung](#streaming-video-labels-stream-processor-results)

## Erstellen des Amazon-Rekognition-Video-Stromprozessors zur Labelerkennung
<a name="streaming-video-create-labels-stream-processor"></a>

Bevor Sie ein Streaming-Video analysieren können, erstellen Sie einen Amazon Rekognition Video Video-Stream-Prozessor () [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html).

Wenn Sie einen Stromprozessor erstellen möchten, der Labels von Interesse und Personen erkennt, geben Sie als Eingabe einen Kinesis-Videostrom (`Input`), Amazon-S3-Bucket-Informationen (`Output`) und einen Amazon-SNS-Themen-ARN (`StreamProcessorNotificationChannel`) ein. Sie können auch eine KMS-Schlüssel-ID angeben, um die an Ihren S3-Bucket gesendeten Daten zu verschlüsseln. Sie geben an, was Sie in `Settings` erkennen möchten, z. B. Personen, Pakete und Personen oder Haustiere, Personen und Pakete. Sie können auch angeben, wo im Frame Amazon Rekognition mit `RegionsOfInterest` überwachen soll. Im Folgenden sehen Sie ein JSON-Beispiel für die Anforderung von `CreateStreamProcessor`.

```
{
  "DataSharingPreference": { "OptIn":TRUE
  },
  "Input": {
    "KinesisVideoStream": {
      "Arn": "arn:aws:kinesisvideo:us-east-1:nnnnnnnnnnnn:stream/muh_video_stream/nnnnnnnnnnnnn"
    }
  },
  "KmsKeyId": "muhkey",
  "Name": "muh-default_stream_processor",
  "Output": {
    "S3Destination": {
      "Bucket": "s3bucket",
      "KeyPrefix": "s3prefix"
    }
  },
  "NotificationChannel": {
    "SNSTopicArn": "arn:aws:sns:us-east-2:nnnnnnnnnnnn:MyTopic"
  },
  "RoleArn": "arn:aws:iam::nnnnnnnnn:role/Admin",
  "Settings": {
    "ConnectedHome": {
      "Labels": [
        "PET"
      ]
    "MinConfidence": 80
    }
  },
  "RegionsOfInterest": [
    {
      "BoundingBox": {
        "Top": 0.11,
        "Left": 0.22,
        "Width": 0.33,
        "Height": 0.44
      }
    },
    {
      "Polygon": [
        {
          "X": 0.11,
          "Y": 0.11
        },
        {
          "X": 0.22,
          "Y": 0.22
        },
        {
          "X": 0.33,
          "Y": 0.33
        }
      ]
    }
  ]
}
```

Beachten Sie, dass Sie den `MinConfidence`-Wert ändern können, wenn Sie den `ConnectedHomeSettings` für den Stromprozessor angeben. `MinConfidence` ist ein numerischer Wert im Bereich von 0 bis 100, der angibt, wie sicher der Algorithmus in Bezug auf seine Vorhersagen ist. Beispielsweise bedeutet eine Benachrichtigung für `person` mit einem Zuverlässigkeitswert von 90, dass der Algorithmus absolut sicher ist, dass die Person im Video anwesend ist. Ein Zuverlässigkeitswert von 10 gibt an, dass es sich möglicherweise um eine Person handelt. Sie können `MinConfidence` auf einen gewünschten Wert Ihrer Wahl zwischen 0 und 100 festlegen, je nachdem, wie oft Sie benachrichtigt werden möchten. Wenn Sie beispielsweise nur benachrichtigt werden möchten, wenn Rekognition absolut sicher ist, dass sich ein Paket im Videoframe befindet, können Sie `MinConfidence` auf 90 setzen.

Standardmäßig ist `MinConfidence ` auf „50“ gesetzt. Wenn Sie den Algorithmus für eine höhere Genauigkeit optimieren möchten, können Sie `MinConfidence` auf einen Wert über 50 einstellen. Sie erhalten dann weniger Benachrichtigungen, aber jede Benachrichtigung ist zuverlässiger. Wenn Sie den Algorithmus für einen höheren Erinnerungswert optimieren möchten, können Sie `MinConfidence` auf einen Wert unter 50 einstellen, um mehr Benachrichtigungen zu erhalten. 

## Starten des Amazon-Rekognition-Video-Stromprozessors zur Labelerkennung
<a name="streaming-video-start-labels-stream-processor"></a>

Sie beginnen die Analyse des Streaming-Videos, indem Sie [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) mit dem Streaming-Prozessor-Namen aufrufen, den Sie in `CreateStreamProcessor` festgelegt haben. Wenn Sie die `StartStreamProcessor`-Operation auf einem Stromprozessor zur Labelerkennung ausführen, geben Sie Start- und Stoppinformationen ein, um die Verarbeitungszeit zu bestimmen.

Wenn Sie den Stromprozessor starten, ändert sich der Status des Label-Erkennungs-Stromprozessors auf folgende Weise:

1. Wenn Sie `StartStreamProcessor` aufrufen, wechselt der Status des Stromprozessors für die Labelerkennung von `STOPPED` oder `FAILED` zu `STARTING`.

1. Solange der Stromprozessor für die Labelerkennung läuft, bleibt er in `STARTING` aktiviert.

1. Wenn der Labelerkennungs-Stromprozessor nicht mehr läuft, wird der Status entweder `STOPPED` oder `FAILED`.

Der `StartSelector` gibt den Startpunkt im Kinesis-Stream an, an dem die Verarbeitung gestartet werden soll. Sie können den KVS-Producer-Zeitstempel oder die KVS-Fragmentnummer verwenden. Weitere Informationen finden Sie unter [Fragment](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_reader_Fragment.html).

**Anmerkung**  
Wenn Sie den KVS-Producer-Zeitstempel verwenden, müssen Sie die Zeit in Millisekunden eingeben.

Der `StopSelector` gibt an, wann die Verarbeitung des Streams beendet werden soll. Sie können eine Höchstdauer für die Verarbeitung des Videos angeben. Standardmäßig ist eine Höchstdauer von 10 Sekunden angegeben. Beachten Sie, dass die tatsächliche Verarbeitungszeit je nach Größe der einzelnen KVS-Fragmente etwas länger als die maximale Dauer sein kann. Wenn die maximale Dauer am Ende eines Fragments erreicht oder überschritten wurde, stoppt die Verarbeitungszeit. 

Im Folgenden sehen Sie ein JSON-Beispiel für die Anforderung von `StartStreamProcessor`.

```
{
   "Name": "string",
   "StartSelector": {
     "KVSStreamStartSelector": { 
         "KVSProducerTimestamp": 1655930623123
      },
        "StopSelector": {
            "MaxDurationInSeconds": 11
      }
   }
}
```

Wenn der Stromprozessor erfolgreich startet, wird eine HTTP-200-Antwort zurückgegeben. Ein leerer JSON-Text ist enthalten.

## Analysieren der Ergebnisse der Labelerkennung
<a name="streaming-video-labels-stream-processor-results"></a>

Es gibt drei Möglichkeiten, wie Amazon Rekognition Video Benachrichtigungen von einem Stream-Prozessor zur Etikettenerkennung veröffentlicht: Amazon SNS SNS-Benachrichtigungen für Objekterkennungsereignisse, eine Amazon SNS-Benachrichtigung für eine end-of-session Zusammenfassung und einen detaillierten Amazon S3-Bucket-Bericht. 
+ Amazon-SNS-Benachrichtigungen für Objekterkennungsereignisse. 

  Wenn Label im Videostrom erkannt werden, erhalten Sie Amazon-SNS-Benachrichtigungen für Objekterkennungsereignisse. Amazon Rekognition veröffentlicht eine Benachrichtigung, wenn ein Objekt oder eine Person von Interesse zum ersten Mal im Videostrom entdeckt wird. Benachrichtigungen enthalten Informationen wie die Art des erkannten Labels, die Zuverlässigkeit und einen Link zum Hero-Bild. Sie enthalten auch ein zugeschnittenes Bild der erkannten Person oder des Objekts und einen Erkennungszeitstempel. Die Benachrichtigung hat das folgende Format:

  ```
  {"Subject": "Rekognition Stream Processing Event",
      "Message": {    
          "inputInformation": {
              "kinesisVideo": {
                  "streamArn": string
              }
          },
          "eventNamespace": {
              "type": "LABEL_DETECTED"
          },
          "labels": [{
              "id": string,
              "name": "PERSON" | "PET" | "PACKAGE",
              "frameImageUri": string,
              "croppedImageUri": string,
              "videoMapping": {
                  "kinesisVideoMapping": {
                      "fragmentNumber": string,
                      "serverTimestamp": number,
                      "producerTimestamp": number,
                      "frameOffsetMillis": number
                  }
              },
              "boundingBox": {
                  "left": number,
                  "top": number,
                  "height": number,
                  "width": number
              }
          }],
          "eventId": string,
          "tags": {
              [string]: string
          },
          "sessionId": string,
          "startStreamProcessorRequest": object
      }
  }
  ```
+  end-of-sessionZusammenfassung von Amazon SNS.

  Sie erhalten auch eine Amazon-SNS-Benachrichtigung, wenn die Stream-Verarbeitungssitzung abgeschlossen ist. In dieser Benachrichtigung sind die Metadaten für die Sitzung aufgeführt. Dazu gehören Details wie die Dauer des Streams, der verarbeitet wurde. Die Benachrichtigung hat das folgende Format:

  ```
  {"Subject": "Rekognition Stream Processing Event",
      "Message": {
          "inputInformation": {
              "kinesisVideo": {
                  "streamArn": string,
                  "processedVideoDurationMillis": number
              }
          },
          "eventNamespace": {
              "type": "STREAM_PROCESSING_COMPLETE"
          },
          "streamProcessingResults": {
              "message": string
          },
          "eventId": string,
          "tags": {
              [string]: string
          },
          "sessionId": string,
          "startStreamProcessorRequest": object
      }
  }
  ```
+ Amazon-S3-Bucket-Bericht.

  Amazon Rekognition Video veröffentlicht die detaillierten Schlussfolgerungsergebnisse eines Videoanalysevorgangs in dem Amazon-S3-Bucket, der in der `CreateStreamProcessor`-Operation angegeben wird. Zu diesen Ergebnissen gehören auch Bildrahmen, in denen ein Objekt von Interesse oder eine Person zum ersten Mal erkannt wurde. 

  Die Frames sind in S3 im folgenden Pfad verfügbar: ObjectKeyPrefix//StreamProcessorNameSessionId/*service\$1determined\$1unique\$1path*. In diesem Pfad **LabelKeyPrefix**befindet sich ein vom Kunden bereitgestelltes optionales Argument, **StreamProcessorName**das der Name der Stream-Prozessor-Ressource und eine eindeutige ID für die Stream-Verarbeitungssitzung **SessionId**ist. Ersetzen Sie diese entsprechend Ihrer Situation.

# Erkennen benutzerdefinierter Label
<a name="labels-detecting-custom-labels"></a>

Mit Amazon Rekognition Custom Labels können Sie Objekte und Szenen in Bildern identifizieren, die auf Ihre geschäftlichen Anforderungen zugeschnitten sind, z. B. Logos oder Maschinenteile. Weitere Informationen finden Sie unter [Was ist Amazon Rekognition Custom Labels?](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html) im *Entwicklerhandbuch für Amazon Rekognition Custom Labels*.