

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Mendeteksi objek dan konsep
<a name="labels"></a>

Bagian ini memberikan informasi untuk mendeteksi label dalam citra dan video dengan Amazon Rekognition Image dan Amazon Rekognition Video. 

 Label atau tag adalah objek atau konsep (termasuk adegan dan tindakan) yang ditemukan dalam gambar atau video berdasarkan isinya. Misalnya, gambar orang di pantai tropis mungkin berisi label seperti Pohon Palem (objek), Pantai (adegan), Lari (aksi), dan Outdoor (konsep). 

**Label didukung oleh operasi deteksi label Rekognition**
+ [Untuk mengunduh daftar label dan kotak pembatas objek terbaru yang didukung oleh Amazon Rekognition, klik di sini.](samples/AmazonRekognitionLabels_v3.0.zip) 
+ Untuk mengunduh daftar label dan kotak pembatas objek sebelumnya, klik [di sini](samples/AmazonRekognitionLabels_v2.0.zip). 

**catatan**  
Amazon Rekognition membuat prediksi biner gender (pria, wanita, gadis, dll.) berdasarkan penampilan fisik seseorang dalam citra tertentu. Prediksi semacam ini tidak dirancang untuk mengategorikan identitas gender seseorang, dan Anda tidak seharusnya menggunakan Amazon Rekognition untuk membuat penentuan seperti itu. Misalnya, seorang aktor pria yang mengenakan wig berambut panjang serta anting-anting untuk suatu peran mungkin diprediksi sebagai perempuan.  
Menggunakan Amazon Rekognition untuk membuat prediksi biner gender paling cocok untuk kasus penggunaan jika statistik distribusi gender agregat perlu dianalisis tanpa mengidentifikasi pengguna tertentu. Misalnya, persentase pengguna perempuan dibandingkan dengan laki-laki di platform media sosial.  
Kami tidak menyarankan penggunaan prediksi biner gender untuk membuat keputusan yang memengaruhi hak, privasi, atau akses seseorang ke layanan.

Amazon Rekognition mengembalikan label dalam bahasa Inggris. Anda dapat menggunakan [Amazon Translate](https://aws.amazon.com/translate/) untuk menerjemahkan label bahasa Inggris ke [bahasa lain](https://docs.aws.amazon.com/translate/latest/dg/what-is.html#language-pairs).

Diagram berikut menunjukkan urutan operasi panggilan, tergantung pada tujuan Anda untuk menggunakan Gambar Rekognition Amazon atau operasi Video Rekognition Amazon: 



![\[Diagram yang menunjukkan alur kerja analisis gambar dan video dengan pemrosesan video yang disimpan dan streaming.\]](http://docs.aws.amazon.com/id_id/rekognition/latest/dg/images/LabelDetectionWorkflow.png)


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

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

Amazon Rekognition Image dan Amazon Rekognition Video dapat mengembalikan kotak pembatas untuk label objek umum seperti mobil, furnitur, pakaian atau hewan peliharaan. Informasi kotak pembatas tidak dikembalikan untuk label objek yang kurang lazim. Anda dapat menggunakan kotak pembatas untuk menemukan lokasi objek yang tepat dalam citra, menghitung instans objek yang terdeteksi, atau mengukur ukuran objek menggunakan dimensi kotak pembatas. 

Misalnya, pada citra berikut, Amazon Rekognition Image mampu mendeteksi keberadaan seseorang, papan luncur, mobil yang terparkir dan informasi lainnya. Amazon Rekognition Image juga mengembalikan kotak pembatas untuk seseorang yang terdeteksi, dan benda-benda lain yang terdeteksi seperti mobil dan roda. 

![\[Orang yang melakukan aksi skateboard antara mobil yang diparkir di jalan kota.\]](http://docs.aws.amazon.com/id_id/rekognition/latest/dg/images/detect-scenes.jpg)


### Skor Keyakinan
<a name="labels-details-image-conf-score"></a>

Video Rekognition Amazon dan Gambar Rekognition Amazon memberikan skor persentase untuk seberapa besar kepercayaan Amazon Rekognition terhadap keakuratan setiap label yang terdeteksi.

### Induk
<a name="labels-details-parents"></a>

Amazon Rekognition Image dan Amazon Rekognition Video menggunakan taksonomi hierarkis label leluhur untuk mengategorikan label. Misalnya, seseorang yang berjalan di seberang jalan mungkin terdeteksi sebagai *Pejalan Kaki*. Label induk untuk *Pejalan Kaki* adalah *Orang*. Kedua label ini dikembalikan dalam respons. Semua label leluhur dikembalikan dan label yang diberikan berisi daftar induknya dan label leluhur lainnya. Misalnya, label kakek-nenek dan kakek-nenek buyut, jika ada. Anda dapat menggunakan label induk untuk membangun grup label terkait dan mengizinkan kueri label serupa dalam satu atau beberapa citra. Sebagai contoh, kueri untuk semua *Kendaraan* mungkin mengembalikan mobil dari satu citra dan sepeda motor dari citra lainya.

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

Gambar Rekognition Amazon dan Video Rekognition Amazon mengembalikan informasi tentang kategori label. Label adalah bagian dari kategori yang mengelompokkan label individu berdasarkan fungsi dan konteks umum, seperti 'Kendaraan dan Otomotif' dan 'Makanan dan Minuman'. Kategori label dapat berupa subkategori dari kategori induk. 

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

Selain mengembalikan label, Amazon Rekognition Image dan Amazon Rekognition Video mengembalikan alias apa pun yang terkait dengan label. Alias adalah label dengan arti atau label yang sama yang dapat dipertukarkan secara visual dengan label utama yang dikembalikan. Misalnya, 'Telepon Seluler' adalah alias 'Ponsel'. 

Di versi sebelumnya, Amazon Rekognition Image mengembalikan alias seperti 'Ponsel' dalam daftar nama label utama yang sama yang berisi 'Ponsel'. Amazon Rekognition Image sekarang mengembalikan 'Ponsel' di bidang yang disebut “alias” dan 'Ponsel' dalam daftar nama label utama. Jika aplikasi Anda bergantung pada struktur yang dikembalikan oleh Rekognition versi sebelumnya, Anda mungkin perlu mengubah respons saat ini yang dikembalikan oleh operasi deteksi label gambar atau video ke dalam struktur respons sebelumnya, di mana semua label dan alias dikembalikan sebagai label utama.

Jika Anda perlu mengubah respons saat ini dari DetectLabels API (untuk deteksi label dalam gambar) menjadi struktur respons sebelumnya, lihat contoh kode di[Mengubah respon DetectLabels](labels-detect-labels-image.md#detectlabels-transform-response). 

Jika Anda perlu mengubah respons saat ini dari GetLabelDetection API (untuk deteksi label dalam video yang disimpan) ke dalam struktur respons sebelumnya, lihat contoh kode di[Mengubah Respon GetLabelDetection](labels-detecting-labels-video.md#getlabeldetection-transform-response).

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

Amazon Rekognition Image mengembalikan informasi tentang kualitas gambar (ketajaman, kecerahan, dan kontras) untuk seluruh gambar. Ketajaman dan kecerahan juga dikembalikan untuk latar depan dan latar belakang gambar. Image Properties juga dapat digunakan untuk mendeteksi warna dominan dari seluruh gambar, latar depan, latar belakang, dan objek dengan kotak pembatas.

![\[Gambar mobil hijau di jalan kota, dengan mobil dikelilingi oleh kotak pembatas.\]](http://docs.aws.amazon.com/id_id/rekognition/latest/dg/images/car_bb.png)


 Berikut ini adalah contoh ImageProperties data yang terkandung dalam respons DetectLabels operasi untuk gambar yang sedang berlangsung:

![\[Tabel yang menunjukkan warna dominan dan metrik kualitas gambar untuk seluruh gambar, latar depan, latar belakang, dan contoh objek dengan kotak pembatas.\]](http://docs.aws.amazon.com/id_id/rekognition/latest/dg/images/image_properties_table.png)


Properti Gambar tidak tersedia untuk Amazon Rekognition Video.

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

Amazon Rekognition Image dan Amazon Rekognition Video mengembalikan versi model deteksi label yang digunakan untuk mendeteksi label dalam citra atau video yang disimpan. 

### Filter Inklusi dan Pengecualian
<a name="labels-details-filters"></a>

Anda dapat memfilter hasil yang ditampilkan oleh Amazon Rekognition Image dan operasi deteksi label Amazon Rekognition Video. Filter hasil dengan memberikan kriteria filtrasi untuk label dan kategori. Filter label bisa inklusif atau eksklusif. 

Lihat [Mendeteksi label dalam citra](labels-detect-labels-image.md) untuk informasi lebih lanjut mengenai penyaringan hasil yang diperoleh dengan`DetectLabels`.

Lihat [Mendeteksi label dalam video](labels-detecting-labels-video.md) untuk informasi lebih lanjut mengenai penyaringan hasil yang diperoleh oleh`GetLabelDetection`.

### Menyortir dan Mengagregasikan Hasil
<a name="labels-details-sorting-aggregating"></a>

Hasil yang diperoleh dari operasi Video Rekognition Amazon tertentu dapat diurutkan dan dikumpulkan menurut stempel waktu dan segmen video. Saat mengambil hasil pekerjaan Deteksi Label atau Moderasi Konten, dengan `GetLabelDetection` atau `GetContentModeration` masing-masing, Anda dapat menggunakan `AggregateBy` argumen `SortBy` dan untuk menentukan bagaimana Anda ingin hasil Anda dikembalikan. Anda dapat menggunakan `SortBy` dengan `TIMESTAMP` atau `NAME` (nama Label), dan menggunakan `TIMESTAMPS` atau `SEGMENTS` dengan AggregateBy argumen.

# Mendeteksi label dalam citra
<a name="labels-detect-labels-image"></a>

Anda dapat menggunakan [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)operasi untuk mendeteksi label (objek dan konsep) dalam gambar dan mengambil informasi tentang properti gambar. Properti gambar mencakup atribut seperti warna latar depan dan latar belakang dan ketajaman, kecerahan, dan kontras gambar. Anda dapat mengambil hanya label dalam gambar, hanya properti gambar, atau keduanya. Sebagai contoh, lihat [Menganalisis citra yang disimpan di bucket Amazon S3](images-s3.md).

Contoh berikut menggunakan berbagai AWS SDKs dan AWS CLI untuk memanggil`DetectLabels`. Untuk informasi tentang respons operasi `DetectLabels`, lihat [DetectLabels respon](#detectlabels-response).

**Untuk mendeteksi label dalam citra**

1. Jika belum:

   1. Buat atau perbarui pengguna dengan `AmazonRekognitionFullAccess` dan `AmazonS3ReadOnlyAccess` izin. Untuk informasi selengkapnya, lihat [Langkah 1: Siapkan akun AWS dan buat Pengguna](setting-up.md#setting-up-iam).

   1. Instal dan konfigurasikan AWS CLI dan AWS SDKs. Untuk informasi selengkapnya, lihat [Langkah 2: Mengatur AWS CLI dan AWS SDKs](setup-awscli-sdk.md).

1. Unggah citra yang berisi satu atau beberapa objek—seperti pohon, rumah, dan perahu—ke bucket S3 Anda. Citra harus dalam format *.jpg* atau *.png*.

   Untuk petunjuk, lihat [Mengunggah Objek ke Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) S3 di Panduan Pengguna *Layanan Penyimpanan Sederhana Amazon*.

1. Gunakan contoh berikut untuk memanggil operasi `DetectLabels`.

------
#### [ Java ]

   Contoh ini menampilkan daftar label yang terdeteksi pada citra input. Ganti nilai-nilai `bucket` dan `photo` dengan nama bucket Amazon S3 dan citra yang Anda gunakan di langkah 2. 

   ```
   package com.amazonaws.samples;
   import java.util.List;
   
   import com.amazonaws.services.rekognition.model.BoundingBox;
   import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Instance;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.services.rekognition.model.Parent;
   import com.amazonaws.services.rekognition.model.S3Object;
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   
   public class DetectLabels {
   
       public static void main(String[] args) throws Exception {
   
           String photo = "photo";
           String bucket = "bucket";
   
           AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
           DetectLabelsRequest request = new DetectLabelsRequest()
                   .withImage(new Image().withS3Object(new S3Object().withName(photo).withBucket(bucket)))
                   .withMaxLabels(10).withMinConfidence(75F);
   
           try {
               DetectLabelsResult result = rekognitionClient.detectLabels(request);
               List<Label> labels = result.getLabels();
   
               System.out.println("Detected labels for " + photo + "\n");
               for (Label label : labels) {
                   System.out.println("Label: " + label.getName());
                   System.out.println("Confidence: " + label.getConfidence().toString() + "\n");
   
                   List<Instance> instances = label.getInstances();
                   System.out.println("Instances of " + label.getName());
                   if (instances.isEmpty()) {
                       System.out.println("  " + "None");
                   } else {
                       for (Instance instance : instances) {
                           System.out.println("  Confidence: " + instance.getConfidence().toString());
                           System.out.println("  Bounding box: " + instance.getBoundingBox().toString());
                       }
                   }
                   System.out.println("Parent labels for " + label.getName() + ":");
                   List<Parent> parents = label.getParents();
                   if (parents.isEmpty()) {
                       System.out.println("  None");
                   } else {
                       for (Parent parent : parents) {
                           System.out.println("  " + parent.getName());
                       }
                   }
                   System.out.println("--------------------");
                   System.out.println();
                  
               }
           } catch (AmazonRekognitionException e) {
               e.printStackTrace();
           }
       }
   }
   ```

------
#### [ AWS CLI ]

   Contoh ini menampilkan output JSON dari operasi CLI `detect-labels`. Ganti nilai-nilai `bucket` dan `photo` dengan nama bucket Amazon S3 dan citra yang Anda gunakan di Langkah 2. Ganti nilai `profile-name` dengan nama profil pengembang Anda. 

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

   Jika Anda mengakses CLI pada perangkat Windows, gunakan tanda kutip ganda alih-alih tanda kutip tunggal dan hindari tanda kutip ganda bagian dalam dengan garis miring terbalik (yaitu\$1) untuk mengatasi kesalahan parser yang mungkin Anda temui. Sebagai contoh, lihat berikut ini: 

   ```
   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 ]

   Contoh ini menampilkan label yang terdeteksi dalam citra input. Dalam fungsi `main`, ganti nilai-nilai `bucket` dan `photo` dengan nama bucket Amazon S3 dan citra yang Anda gunakan pada Langkah 2. Ganti nilai `profile_name` di baris yang membuat sesi Rekognition dengan nama profil pengembang Anda. 

   ```
   #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 ]

   Contoh ini menampilkan daftar label yang terdeteksi pada citra input. Ganti nilai-nilai `bucket` dan `photo` dengan nama bucket Amazon S3 dan citra yang Anda gunakan di Langkah 2. 

   ```
   //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
   using System;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectLabels
   {
       public static void Example()
       {
           String photo = "input.jpg";
           String bucket = "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 ]

   Contoh ini menampilkan daftar label yang terdeteksi pada citra input. Ganti nilai-nilai `bucket` dan `photo` dengan nama bucket Amazon S3 dan citra yang Anda gunakan di Langkah 2. 

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

------
#### [ Node.js ]

   Contoh ini menampilkan daftar label yang terdeteksi pada citra input. Ganti nilai-nilai `bucket` dan `photo` dengan nama bucket Amazon S3 dan citra yang Anda gunakan di Langkah 2. Ganti nilai `profile_name` di baris yang membuat sesi Rekognition dengan nama profil pengembang Anda. 

   Jika Anda menggunakan TypeScript definisi, Anda mungkin perlu menggunakan `import AWS from 'aws-sdk'` alih-alih`const AWS = require('aws-sdk')`, untuk menjalankan program dengan Node.js. Anda dapat melihat [AWS SDK for Javascript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) untuk detailnya selengkapnya. Tergantung bagaimana konfigurasi diatur, Anda juga mungkin perlu menentukan wilayah Anda dengan `AWS.config.update({region:region});`.

   ```
                                   
   // Load the SDK
   var AWS = require('aws-sdk');
   const bucket = 'bucket-name' // the bucketname without s3://
   const photo  = 'image-name' // the name of file
   
   var credentials = new AWS.SharedIniFileCredentials({profile: 'profile-name'});
   AWS.config.credentials = credentials;
   AWS.config.update({region:'region-name'});
   
   const client = new AWS.Rekognition();
   const params = {
     Image: {
       S3Object: {
         Bucket: bucket,
         Name: photo
       },
     },
     MaxLabels: 10
   }
   client.detectLabels(params, function(err, response) {
     if (err) {
       console.log(err, err.stack); // if an error occurred
     } else {
       console.log(`Detected labels for: ${photo}`)
       response.Labels.forEach(label => {
         console.log(`Label:      ${label.Name}`)
         console.log(`Confidence: ${label.Confidence}`)
         console.log("Instances:")
         label.Instances.forEach(instance => {
           let box = instance.BoundingBox
           console.log("  Bounding box:")
           console.log(`    Top:        ${box.Top}`)
           console.log(`    Left:       ${box.Left}`)
           console.log(`    Width:      ${box.Width}`)
           console.log(`    Height:     ${box.Height}`)
           console.log(`  Confidence: ${instance.Confidence}`)
         })
         console.log("Parents:")
         label.Parents.forEach(parent => {
           console.log(`  ${parent.Name}`)
         })
         console.log("------------")
         console.log("")
       }) // for response.labels
     } // if
   });
   ```

------
#### [ Java V2 ]

   Kode ini diambil dari GitHub repositori contoh SDK AWS Dokumentasi. Lihat contoh lengkapnya [di sini](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 permintaan operasi
<a name="detectlabels-request"></a>

Input ke `DetectLabel` adalah citra. Dalam contoh input JSON ini, citra sumber dimuat dari Bucket Amazon S3. `MaxLabels` adalah jumlah maksimum label yang dikembalikan dalam respons. `MinConfidence` adalah kepercayaan minimum yang harus dimiliki Amazon Rekognition Image dalam keakuratan label yang terdeteksi agar dapat dikembalikan dalam respons.

Fitur memungkinkan Anda menentukan satu atau lebih fitur gambar yang ingin Anda kembalikan, memungkinkan Anda untuk memilih `GENERAL_LABELS` dan`IMAGE_PROPERTIES`. Termasuk `GENERAL_LABELS` akan mengembalikan label yang terdeteksi dalam gambar input, sementara termasuk `IMAGE_PROPERTIES` akan memungkinkan Anda untuk mengakses warna dan kualitas gambar. 

Pengaturan memungkinkan Anda memfilter item yang dikembalikan untuk `IMAGE_PROPERTIES` fitur `GENERAL_LABELS` dan fitur. Untuk label, Anda dapat menggunakan filter inklusif dan eksklusif. Anda juga dapat memfilter berdasarkan label khusus, label individual atau berdasarkan kategori label: 
+ LabelInclusionFilters - Memungkinkan Anda menentukan label mana yang ingin Anda sertakan dalam respons.
+ LabelExclusionFilters - Memungkinkan Anda menentukan label mana yang ingin Anda kecualikan dari respons.
+ LabelCategoryInclusionFilters - Memungkinkan Anda menentukan kategori label mana yang ingin Anda sertakan dalam respons.
+ LabelCategoryExclusionFilters - Memungkinkan Anda menentukan kategori label mana yang ingin Anda kecualikan dari respons.

 Anda juga dapat menggabungkan filter inklusif dan eksklusif sesuai dengan kebutuhan Anda, tidak termasuk beberapa label atau kategori dan termasuk yang lain. 

`IMAGE_PROPERTIES`mengacu pada warna dominan gambar dan atribut kualitas seperti ketajaman, kecerahan, dan kontras. Saat mendeteksi `IMAGE_PROPERTIES` Anda dapat menentukan jumlah maksimum warna dominan untuk kembali (default adalah 10) dengan menggunakan `MaxDominantColors` parameter.

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

Respons dari `DetectLabels` adalah array label yang terdeteksi dalam citra dan tingkat kepercayaan yang digunakan untuk mendeteksinya. 

Berikut ini adalah contoh respons dari `DetectLabels`. Contoh respons di bawah ini berisi berbagai atribut yang dikembalikan untuk GENERAL\$1LABELS, termasuk:
+ Nama - Nama label yang terdeteksi. Dalam contoh ini, operasi mendeteksi objek dengan label Ponsel.
+ Keyakinan - Setiap label memiliki tingkat kepercayaan yang terkait. Dalam contoh ini, kepercayaan untuk label adalah 99,36%.
+ Orang tua - Label leluhur untuk label yang terdeteksi. Dalam contoh ini, label Ponsel memiliki satu label induk bernama Telepon.
+ Alias - Informasi tentang kemungkinan Alias untuk label. Dalam contoh ini, label Ponsel memiliki kemungkinan alias Ponsel.
+ Kategori - Kategori label yang dimiliki label yang terdeteksi. Dalam contoh ini, itu adalah Teknologi dan Komputasi.

Respons untuk label objek umum mencakup informasi kotak pembatas untuk lokasi label pada citra input. Misalnya, label Orang memiliki array instans yang berisi dua kotak batas. Ini adalah lokasi dari dua orang yang terdeteksi dalam citra.

Respons juga mencakup atribut mengenai IMAGE\$1PROPERTIES. Atribut yang disajikan oleh fitur IMAGE\$1PROPERTIES adalah:
+ Kualitas - Informasi tentang Ketajaman, Kecerahan, dan Kontras gambar input, diberi skor antara 0 hingga 100. Kualitas dilaporkan untuk seluruh gambar dan untuk latar belakang dan latar depan gambar, jika tersedia. Namun, Kontras hanya dilaporkan untuk seluruh gambar sementara Ketajaman dan Kecerahan juga dilaporkan untuk Latar Belakang dan Latar Depan. 
+  Warna Dominan - Array warna dominan dalam gambar. Setiap warna dominan dijelaskan dengan nama warna yang disederhanakan, palet warna CSS, nilai RGB, dan kode hex. 
+  Foreground - Informasi tentang Warna dominan, Ketajaman dan Kecerahan latar depan gambar input. 
+  Latar Belakang - Informasi tentang Warna dominan, Ketajaman dan Kecerahan latar belakang gambar input. 

Ketika GENERAL\$1LABELS dan IMAGE\$1PROPERTIES digunakan bersama sebagai parameter input, Amazon Rekognition Image juga akan mengembalikan warna dominan objek dengan kotak pembatas. 

Bidang `LabelModelVersion` berisi nomor versi model deteksi yang digunakan oleh `DetectLabels`. 

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

## Mengubah respon DetectLabels
<a name="detectlabels-transform-response"></a>

Saat menggunakan DetectLabels API, Anda mungkin memerlukan struktur respons untuk meniru struktur respons API yang lebih lama, di mana label utama dan alias terkandung dalam daftar yang sama. 

Berikut ini adalah contoh respons API saat ini dari [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" 
                }
             ]
        }
 ]
```

Contoh berikut menunjukkan respons sebelumnya dari [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" 
                }
             ]
         },
]
```

Jika diperlukan, Anda dapat mengubah respons saat ini untuk mengikuti format respons yang lebih lama. Anda dapat menggunakan kode contoh berikut untuk mengubah respons API terbaru ke struktur respons API sebelumnya:

------
#### [ Python ]

Contoh kode berikut menunjukkan cara mengubah respons saat ini dari DetectLabels API. Dalam contoh kode di bawah ini, Anda dapat mengganti nilai *EXAMPLE\$1INFERENCE\$1OUTPUT* dengan output dari DetectLabels operasi yang telah Anda jalankan.

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

Di bawah ini adalah contoh respons yang diubah:

```
#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"
            ]
        }
    ]
}
```

------

# Mendeteksi label dalam video
<a name="labels-detecting-labels-video"></a>

Amazon Rekognition Video dapat mendeteksi label (objek dan konsep), dan waktu label terdeteksi, dalam video. Untuk contoh kode SDK, lihat [Menganalisis video yang disimpan di bucket Amazon S3 dengan Java atau Python (SDK)](video-analyzing-with-sqs.md). AWS CLI Sebagai contoh, lihat[Menganalisis video dengan AWS Command Line Interface](video-cli-commands.md).

Deteksi label dengan Amazon Rekognition Video adalah operasi tidak sinkron. Untuk memulai deteksi label dalam video, panggil [StartLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartlabelDetection.html). 

Amazon Rekognition Video menerbitkan status penyelesaian analisis video ke topik Amazon Simple Notification Service. Jika analisis video berhasil, panggil [GetLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetLabelDetection.html) untuk mendapatkan label yang terdeteksi. Untuk informasi tentang memanggil operasi API analisis video, lihat [Memanggil operasi Amazon Rekognition Video](api-video.md). 

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

Contoh berikut adalah permintaan untuk `StartLabelDetection` operasi. Anda menyediakan `StartLabelDetection` operasi dengan video yang disimpan dalam ember Amazon S3. Dalam permintaan contoh JSON, bucket Amazon S3 dan nama video ditentukan, bersama `MinConfidence` dengan, `Features``Settings`, dan. `NotificationChannel`

`MinConfidence`adalah keyakinan minimum yang harus dimiliki Video Rekognition Amazon dalam keakuratan label yang terdeteksi, atau kotak pembatas instance (jika terdeteksi), agar dapat dikembalikan dalam respons.

Dengan`Features`, Anda dapat menentukan bahwa Anda ingin GENERAL\$1LABELS dikembalikan sebagai bagian dari respons.

Dengan`Settings`, Anda dapat memfilter item yang dikembalikan untuk GENERAL\$1LABELS. Untuk label, Anda dapat menggunakan filter inklusif dan eksklusif. Anda juga dapat memfilter berdasarkan label khusus, label individual atau berdasarkan kategori label: 
+ `LabelInclusionFilters`- Digunakan untuk menentukan label mana yang ingin Anda sertakan dalam respons 
+ `LabelExclusionFilters`- Digunakan untuk menentukan label mana yang ingin Anda kecualikan dari respons.
+ `LabelCategoryInclusionFilters`- Digunakan untuk menentukan kategori label mana yang ingin Anda sertakan dalam respons.
+ `LabelCategoryExclusionFilters`- Digunakan untuk menentukan kategori label mana yang ingin Anda kecualikan dari respons.

Anda juga dapat menggabungkan filter inklusif dan eksklusif sesuai dengan kebutuhan Anda, tidak termasuk beberapa label atau kategori dan termasuk yang lain.

`NotificationChannel`adalah ARN dari topik Amazon SNS yang Anda inginkan agar Video Rekognition Amazon mempublikasikan status penyelesaian operasi deteksi label. Jika Anda menggunakan kebijakan `AmazonRekognitionServiceRole` izin, maka topik Amazon SNS harus memiliki nama topik yang dimulai dengan Rekognition.

Berikut ini adalah contoh `StartLabelDetection` permintaan dalam bentuk JSON, termasuk filter:

```
{
    "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 Respon Operasi
<a name="getlabeldetection-operation-response"></a>

`GetLabelDetection` mengembalikan array (`Labels`) yang berisi informasi tentang label yang terdeteksi dalam video. Array dapat diurutkan berdasarkan waktu atau oleh label yang terdeteksi saat menentukan `SortBy` parameter.Anda juga dapat memilih bagaimana item respons digabungkan dengan menggunakan parameter. `AggregateBy` 

Contoh berikut adalah respons JSON dari `GetLabelDetection`. Dalam respons, perhatikan hal berikut:
+ **Urutkan sesuai urutan** - array label yang dikembalikan diurutkan berdasarkan waktu. Untuk mengurutkan berdasarkan label, tentukan `NAME` dalam parameter input `SortBy` untuk `GetLabelDetection`. Jika label muncul beberapa kali dalam video, akan ada beberapa instans elemen ([LabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_LabelDetection.html)). Urutan oder default adalah`TIMESTAMP`, sedangkan urutan urutan sekunder adalah`NAME`.
+ **Informasi label** - Elemen `LabelDetection` array berisi objek ([Label](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Label.html)), yang pada gilirannya berisi nama label dan kepercayaan Amazon Rekognition dalam keakuratan label yang terdeteksi. Sebuah `Label` objek juga mencakup taksonomi hierarkis label dan informasi kotak pembatas untuk label umum. `Timestamp`adalah waktu label terdeteksi, didefinisikan sebagai jumlah milidetik yang berlalu sejak awal video. 

  Informasi tentang Kategori atau Alias apa pun yang terkait dengan label juga dikembalikan. Untuk hasil yang dikumpulkan berdasarkan video `SEGMENTS``StartTimestampMillis`, `DurationMillis` struktur`EndTimestampMillis`, dan dikembalikan, yang menentukan waktu mulai, waktu akhir, dan durasi segmen masing-masing.
+ **Agregasi** - Menentukan bagaimana hasil dikumpulkan ketika dikembalikan. Defaultnya adalah agregat dengan`TIMESTAMPS`. Anda juga dapat memilih untuk agregat menurut`SEGMENTS`, yang mengumpulkan hasil melalui jendela waktu. Jika digabungkan dengan`SEGMENTS`, informasi tentang instance yang terdeteksi dengan kotak pembatas tidak dikembalikan. Hanya label yang terdeteksi selama segmen yang dikembalikan.
+ **Informasi halaman** - Contoh menunjukkan satu halaman informasi deteksi label. Anda dapat menentukan berapa banyak objek `LabelDetection` yang akan dikembalikan dalam parameter input `MaxResults` untuk `GetLabelDetection`. Jika ada lebih banyak hasil daripada `MaxResults`, `GetLabelDetection` mengembalikan token (`NextToken`) yang digunakan untuk mendapatkan halaman hasil berikutnya. Untuk informasi selengkapnya, lihat [Mendapatkan hasil analisis Amazon Rekognition Video](api-video.md#api-video-get).
+ **Informasi video** - Respons mencakup informasi tentang format video (`VideoMetadata`) di setiap halaman informasi yang dikembalikan oleh `GetLabelDetection`.

Berikut ini adalah contoh GetLabelDetection respons dalam bentuk JSON dengan agregasi oleh 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
    }
}
```

Berikut ini adalah contoh GetLabelDetection respon dalam bentuk JSON dengan agregasi oleh SEGMENTS:

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

## Mengubah Respon GetLabelDetection
<a name="getlabeldetection-transform-response"></a>

Saat mengambil hasil dengan operasi GetLabelDetection API, Anda mungkin memerlukan struktur respons untuk meniru struktur respons API yang lebih lama, di mana label utama dan alias terkandung dalam daftar yang sama.

Contoh respons JSON yang ditemukan di bagian sebelumnya menampilkan bentuk respons API saat ini dari. GetLabelDetection

Contoh berikut menunjukkan respons sebelumnya dari 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
    }
}
```

Jika diperlukan, Anda dapat mengubah respons saat ini untuk mengikuti format respons yang lebih lama. Anda dapat menggunakan kode contoh berikut untuk mengubah respons API terbaru ke struktur respons API sebelumnya: 

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

# Mendeteksi label dalam acara video streaming
<a name="streaming-video-detect-labels"></a>

Anda dapat menggunakan Amazon Rekognition Video untuk mendeteksi label dalam streaming video. Untuk melakukan ini, Anda membuat prosesor streaming ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)) untuk memulai dan mengelola analisis video streaming. 

Amazon Rekognition Video menggunakan Amazon Kinesis Video Streams untuk menerima dan memproses video streaming. Saat Anda membuat prosesor streaming, Anda memilih apa yang Anda ingin dideteksi oleh prosesor aliran. Anda dapat memilih orang, paket dan hewan peliharaan, atau orang dan paket. Hasil analisis adalah output ke bucket Amazon S3 Anda dan di notifikasi Amazon SNS. Perhatikan bahwa Amazon Rekognition Video mendeteksi keberadaan seseorang dalam video, tetapi tidak mendeteksi apakah orang tersebut adalah individu tertentu. Untuk mencari wajah dari koleksi dalam video streaming, lihat[Mencari wajah dalam koleksi dalam streaming video](collections-streaming.md). 

Untuk menggunakan Amazon Rekognition Video dengan streaming video, aplikasi Anda memerlukan yang berikut:
+ Aliran video Kinesis untuk mengirimkan video streaming ke Amazon Rekognition Video. Untuk informasi selengkapnya, lihat [Panduan Developer Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Sebuah pemroses aliran Amazon Rekognition Video untuk mengelola analisis video streaming. Untuk informasi selengkapnya, lihat [Ikhtisar operasi prosesor aliran Video Rekognition Amazon](streaming-video.md#using-rekognition-video-stream-processor).
+ Bucket Amazon S3. Amazon Rekognition Video menerbitkan output sesi ke bucket S3. Outputnya mencakup bingkai gambar di mana seseorang atau objek yang menarik terdeteksi untuk pertama kalinya. Anda harus menjadi pemilik ember S3.
+ Topik Amazon SNS tempat Amazon Rekognition Video menerbitkan peringatan cerdas dan ringkasannya. end-of-session

**Topics**
+ [Mempersiapkan Amazon Rekognition Video Amazon dan sumber daya Amazon Kinesis](streaming-labels-setting-up.md)
+ [Memanggil operasi deteksi label untuk streaming acara video](streaming-labels-detection.md)

# Mempersiapkan Amazon Rekognition Video Amazon dan sumber daya Amazon Kinesis
<a name="streaming-labels-setting-up"></a>

 Prosedur berikut menjelaskan langkah-langkah yang Anda ambil untuk menyediakan aliran video Kinesis dan sumber daya lain yang digunakan untuk mendeteksi label dalam video streaming.

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

Untuk menjalankan prosedur ini, AWS SDK untuk Java harus diinstal. Untuk informasi selengkapnya, lihat [Memulai dengan Amazon Rekognition](getting-started.md). AWS Akun yang Anda gunakan memerlukan izin akses ke Amazon Rekognition API. Untuk informasi selengkapnya, lihat [Tindakan yang Ditetapkan oleh Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) di *Panduan Pengguna IAM*. 

**Untuk mendeteksi label dalam aliran video (AWS SDK)**

1. Buat bucket Amazon S3. Perhatikan nama bucket dan awalan kunci apa pun yang ingin Anda gunakan. Anda menggunakan informasi ini nanti.

1. Buat topik Amazon SNS. Anda dapat menggunakannya untuk menerima pemberitahuan ketika objek yang menarik pertama kali terdeteksi dalam aliran video. Perhatikan Nama Sumber Daya Amazon (ARN) untuk topik tersebut. Untuk informasi selengkapnya, lihat [Membuat topik Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html) di panduan pengembang Amazon SNS.

1. Berlangganan titik akhir ke topik Amazon SNS. Untuk informasi selengkapnya, lihat [Berlangganan topik Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) di panduan pengembang Amazon SNS.

1. [Buat aliran video Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) dan catat Nama Sumber Daya Amazon (ARN) dari aliran tersebut.

1. Jika Anda belum melakukannya, buat peran layanan IAM untuk memberikan akses Video Rekognition Amazon ke aliran video Kinesis, bucket S3, dan topik Amazon SNS Anda. Untuk informasi selengkapnya, lihat [Memberikan akses untuk prosesor aliran deteksi label](#streaming-labels-giving-access).

Anda kemudian dapat [membuat prosesor aliran deteksi label](streaming-labels-detection.md#streaming-video-create-labels-stream-processor) dan [memulai prosesor aliran](streaming-labels-detection.md#streaming-video-start-labels-stream-processor) menggunakan nama prosesor aliran yang Anda pilih.

**catatan**  
Mulai prosesor streaming hanya setelah Anda memverifikasi bahwa Anda dapat menelan media ke dalam aliran video Kinesis. 

## Orientasi dan pengaturan kamera
<a name="streaming-labels-camera-setup"></a>

Acara Video Streaming Video Amazon Rekognition dapat mendukung semua kamera yang didukung oleh Kinesis Video Streams. Untuk hasil terbaik, kami sarankan menempatkan kamera antara 0 hingga 45 derajat dari tanah. Kamera harus dalam posisi tegak kanonik. Misalnya, jika ada seseorang dalam bingkai, orang tersebut harus berorientasi vertikal, dan kepala orang tersebut harus lebih tinggi dalam bingkai daripada kaki.

## Memberikan akses untuk prosesor aliran deteksi label
<a name="streaming-labels-giving-access"></a>

Anda menggunakan peran layanan AWS Identity and Access Management (IAM) untuk memberikan akses baca Video Rekognition Amazon ke aliran video Kinesis. Untuk melakukannya, gunakan peran IAM untuk memberikan akses Video Rekognition Amazon ke bucket Amazon S3 Anda dan ke topik Amazon SNS.

Anda dapat membuat kebijakan izin yang memungkinkan akses Video Rekognition Amazon ke topik Amazon SNS yang ada, bucket Amazon S3, dan aliran video Kinesis. Untuk step-by-step prosedur menggunakan AWS CLI, lihat[AWS CLI perintah untuk mengatur peran IAM deteksi label](#streaming-labels-giving-access-cli). 

**Untuk memberikan Amazon Rekognition Video akses ke sumber daya untuk deteksi label**

1. [ Buat kebijakan izin baru dengan editor kebijakan IAM JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor), dan gunakan kebijakan berikut. Ganti `kvs-stream-name` dengan nama aliran video Kinesis, `topicarn` dengan Nama Sumber Daya Amazon (ARN) dari topik Amazon SNS yang ingin Anda gunakan, dan `bucket-name` dengan nama bucket Amazon S3.

1. [Buat peran layanan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console), atau perbarui peran layanan IAM yang ada. Gunakan informasi berikut ini untuk membuat peran layanan IAM:

   1. Pilih **Rekognition** untuk nama layanan.

   1. Pilih **Rekognition** untuk kasus penggunaan peran layanan.

   1. Lampirkan kebijakan izin yang Anda buat pada langkah 1.

1. Catat ARN peran layanan. Anda membutuhkannya untuk membuat prosesor streaming sebelum Anda melakukan operasi analisis video.

1. (Opsional) Jika Anda menggunakan AWS KMS kunci Anda sendiri untuk mengenkripsi data yang dikirim ke bucket S3, Anda harus menambahkan pernyataan berikut dengan peran IAM. (Ini adalah peran IAM yang Anda buat untuk kebijakan kunci, yang sesuai dengan kunci terkelola pelanggan yang ingin Anda gunakan.)

   ```
       
               {
                          "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 perintah untuk mengatur peran IAM deteksi label
<a name="streaming-labels-giving-access-cli"></a>

Jika Anda belum melakukannya, atur dan konfigurasikan AWS CLI dengan kredensil Anda.

Masukkan perintah berikut ke dalam AWS CLI untuk mengatur peran IAM dengan izin yang diperlukan untuk deteksi label.

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

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

1. Buat file kebijakan hubungan kepercayaan (misalnya, assume-role-rekognition .json) dengan konten berikut.

------
#### [ 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. Jika nama topik SNS Anda yang ingin Anda terima notifikasi tidak dimulai dengan awalan "AmazonRekognition", tambahkan kebijakan berikut:

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

1. Jika Anda menggunakan kunci AWS KMS Anda sendiri untuk mengenkripsi data yang dikirim ke bucket Amazon S3, perbarui kebijakan kunci kunci terkelola pelanggan yang ingin Anda gunakan.

   1. Buat file kms\$1key\$1policy.json yang berisi konten berikut:

      ```
      {
      "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`. Ganti KMS\$1KEY\$1ID dengan ID kunci KMS yang Anda buat.

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

# Memanggil operasi deteksi label untuk streaming acara video
<a name="streaming-labels-detection"></a>

Amazon Rekognition Video dapat mendeteksi orang atau objek yang relevan dalam video streaming dan memberi tahu Anda ketika mereka terdeteksi. Saat Anda membuat prosesor aliran deteksi label, pilih label apa yang ingin dideteksi oleh Video Rekognition Amazon. Ini bisa berupa orang, paket dan hewan peliharaan, atau orang, paket, dan hewan peliharaan. Pilih hanya label tertentu yang ingin Anda deteksi. Dengan begitu, satu-satunya label yang relevan membuat notifikasi. Anda dapat mengonfigurasi opsi untuk menentukan kapan harus menyimpan informasi video, dan kemudian melakukan pemrosesan tambahan berdasarkan label yang terdeteksi dalam bingkai.

Setelah mengatur sumber daya, proses untuk mendeteksi label dalam video streaming adalah sebagai berikut:

1. Buat prosesor aliran

1. Mulai prosesor streaming

1. Jika objek yang menarik terdeteksi, Anda menerima pemberitahuan Amazon SNS untuk kemunculan pertama setiap objek yang menarik.

1. Prosesor aliran berhenti ketika waktu yang `MaxDurationInSeconds` ditentukan selesai.

1. Anda menerima pemberitahuan Amazon SNS akhir dengan ringkasan acara.

1. Amazon Rekognition Video menerbitkan ringkasan sesi terperinci ke bucket S3 Anda.

**Topics**
+ [Membuat prosesor aliran deteksi label Amazon Rekognition Video](#streaming-video-create-labels-stream-processor)
+ [Memulai prosesor aliran deteksi label Amazon Rekognition Video](#streaming-video-start-labels-stream-processor)
+ [Menganalisis hasil deteksi label](#streaming-video-labels-stream-processor-results)

## Membuat prosesor aliran deteksi label Amazon Rekognition Video
<a name="streaming-video-create-labels-stream-processor"></a>

Sebelum Anda dapat menganalisis video streaming, Anda membuat pemroses aliran Amazon Rekognition Video ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)).

Jika Anda ingin membuat prosesor streaming untuk mendeteksi label yang diminati dan orang, berikan sebagai input Kinesis video stream (`Input`), informasi bucket Amazon S3 (), dan topik Amazon SNS ARN `Output` (). `StreamProcessorNotificationChannel` Anda juga dapat memberikan ID kunci KMS untuk mengenkripsi data yang dikirim ke bucket S3 Anda. Anda menentukan apa yang ingin Anda deteksi`Settings`, seperti orang, paket dan orang, atau hewan peliharaan, orang, dan paket. Anda juga dapat menentukan di mana dalam bingkai yang ingin Anda pantau Amazon Rekognition. `RegionsOfInterest` Berikut ini adalah contoh JSON untuk permintaan `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
        }
      ]
    }
  ]
}
```

Perhatikan bahwa Anda dapat mengubah `MinConfidence` nilai saat Anda menentukan `ConnectedHomeSettings` untuk prosesor aliran. `MinConfidence`adalah nilai numerik mulai dari 0 hingga 100 yang menunjukkan seberapa pasti algoritme tentang prediksinya. Misalnya, pemberitahuan untuk `person` dengan nilai kepercayaan 90 berarti bahwa algoritme benar-benar yakin bahwa orang tersebut hadir dalam video. Nilai kepercayaan 10 menunjukkan bahwa mungkin ada seseorang. Anda dapat mengatur `MinConfidence` ke nilai yang diinginkan dari pilihan Anda antara 0 dan 100 tergantung pada seberapa sering Anda ingin diberi tahu. Misalnya, jika Anda ingin diberi tahu hanya ketika Rekognition benar-benar yakin ada paket dalam bingkai video maka Anda dapat mengatur ke 90. `MinConfidence`

Secara default, `MinConfidence ` diatur ke 50. Jika Anda ingin mengoptimalkan algoritma untuk presisi yang lebih tinggi, maka Anda dapat mengatur `MinConfidence` menjadi lebih tinggi dari 50. Anda kemudian menerima lebih sedikit pemberitahuan, tetapi setiap pemberitahuan lebih dapat diandalkan. Jika Anda ingin mengoptimalkan algoritme untuk penarikan yang lebih tinggi, maka Anda dapat mengatur `MinConfidence` menjadi lebih rendah dari 50 untuk menerima lebih banyak notifikasi. 

## Memulai prosesor aliran deteksi label Amazon Rekognition Video
<a name="streaming-video-start-labels-stream-processor"></a>

Anda mulai menganalisis streaming video dengan memanggil [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) dengan nama pemroses aliran yang Anda tentukan di `CreateStreamProcessor`. Saat Anda menjalankan `StartStreamProcessor` operasi pada prosesor aliran deteksi label, Anda memasukkan informasi mulai dan berhenti untuk menentukan waktu pemrosesan.

Saat Anda memulai prosesor streaming, status prosesor aliran deteksi label berubah dengan cara berikut:

1. Saat Anda menelepon`StartStreamProcessor`, status prosesor aliran deteksi label beralih dari `STOPPED` atau `FAILED` ke`STARTING`.

1. Saat prosesor aliran deteksi label berjalan, prosesor tetap masuk`STARTING`.

1. Ketika prosesor aliran deteksi label selesai berjalan, status menjadi salah satu `STOPPED` atau`FAILED`.

`StartSelector`Menentukan titik awal dalam aliran Kinesis untuk memulai pemrosesan. Anda dapat menggunakan stempel waktu Produsen KVS atau nomor Fragmen KVS. Untuk informasi selengkapnya, lihat [Fragmen.](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_reader_Fragment.html)

**catatan**  
Jika Anda menggunakan stempel waktu Produsen KVS, Anda harus memasukkan waktu dalam milidetik.

`StopSelector`Menentukan kapan harus berhenti memproses aliran. Anda dapat menentukan jumlah waktu maksimum untuk memproses video. Defaultnya adalah durasi maksimum 10 detik. Perhatikan bahwa waktu pemrosesan sebenarnya mungkin sedikit lebih lama dari durasi maksimum, tergantung pada ukuran fragmen KVS individu. Jika durasi maksimum telah tercapai atau terlampaui pada akhir fragmen, waktu pemrosesan berhenti. 

Berikut ini adalah contoh JSON untuk permintaan `StartStreamProcessor`.

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

Jika prosesor streaming berhasil dimulai, respons HTTP 200 dikembalikan. Badan JSON kosong disertakan.

## Menganalisis hasil deteksi label
<a name="streaming-video-labels-stream-processor-results"></a>

Ada tiga cara Amazon Rekognition Video menerbitkan notifikasi dari prosesor aliran deteksi label: Notifikasi Amazon SNS untuk peristiwa deteksi objek, notifikasi Amazon SNS untuk ringkasan, end-of-session dan laporan bucket Amazon S3 terperinci. 
+ Notifikasi Amazon SNS untuk peristiwa deteksi objek. 

  Jika label terdeteksi dalam aliran video, Anda menerima notifikasi Amazon SNS untuk peristiwa deteksi objek. Amazon Rekognition menerbitkan pemberitahuan pertama kali bahwa seseorang atau objek yang menarik terdeteksi dalam aliran video. Pemberitahuan mencakup informasi seperti jenis label yang terdeteksi, kepercayaan diri, dan tautan ke gambar pahlawan. Mereka juga termasuk gambar yang dipotong dari orang atau objek yang terdeteksi dan stempel waktu deteksi. Pemberitahuan memiliki format berikut:

  ```
  {"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
      }
  }
  ```
+ Ringkasan Amazon SNS end-of-session.

  Anda juga menerima notifikasi Amazon SNS saat sesi pemrosesan streaming selesai. Pemberitahuan ini mencantumkan metadata untuk sesi tersebut. Ini termasuk detail seperti durasi aliran yang diproses. Pemberitahuan memiliki format berikut:

  ```
  {"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
      }
  }
  ```
+ Laporan ember Amazon S3.

  Amazon Rekognition Video menerbitkan hasil inferensi terperinci dari operasi analisis video ke bucket Amazon S3 yang disediakan dalam operasi. `CreateStreamProcessor` Hasil ini termasuk bingkai gambar di mana objek yang menarik atau orang terdeteksi untuk pertama kalinya. 

  Bingkai tersedia di S3 di jalur berikut: ObjectKeyPrefix//StreamProcessorNameSessionId/*service\$1determined\$1unique\$1path*. Di jalur ini, **LabelKeyPrefix**adalah argumen opsional yang diberikan pelanggan, **StreamProcessorName**adalah nama sumber daya prosesor aliran, dan **SessionId**merupakan ID unik untuk sesi pemrosesan aliran. Ganti ini sesuai dengan situasi Anda.

# Mendeteksi label kustom
<a name="labels-detecting-custom-labels"></a>

Label Kustom Amazon Rekognition dapat mengidentifikasi objek dan pemandangan dalam citra yang khusus untuk kebutuhan bisnis Anda, seperti logo atau bagian-bagian mesin rekayasa. Untuk informasi selengkapnya, lihat [Apa itu Label Kustom Amazon Rekognition?](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html) dalam *Panduan Developer Label Kustom Amazon Rekognition*.