翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# オブジェクトおよび概念の検出
<a name="labels"></a>

このセクションでは、Amazon Rekognition イメージおよび Amazon Rekognition Video を使用してイメージおよびビデオのラベルを検出する情報について説明します。

 ラベルやタグは、イメージやビデオ内でそのコンテンツに基づいて発見されたオブジェクトや概念 (シーンやアクションを含む) です。例えば、南国のビーチでくつろぐ人々のイメージには、ヤシの木 (オブジェクト)、ビーチ (シーン)、ランニング (アクション)、アウトドア (概念) が含まれる場合があります。

**Rekognition のラベル検出オペレーションでサポートされているラベル**
+ Amazon Rekognition でサポートされているラベルおよびオブジェクト境界ボックスの完全なリストをダウンロードするには、[こちら](samples/AmazonRekognitionLabels_v3.0.zip)をクリックしてください。
+ ラベルおよびオブジェクト境界ボックスの以前のリストをダウンロードするには、[こちら](samples/AmazonRekognitionLabels_v2.0.zip)をクリックしてください。

**注記**  
Amazon Rekognition は、特定のイメージ内の人物の物理的な外観に基づいて、性別バイナリ（男性、女性、女の子など）の予測を作成します。この種の予測は、人物の性自認を分類するためのものではないため、Amazon Rekognition を使用してこのような判断を下さないようにしましょう。たとえば、ある役のために長髪のかつらやイヤリングを身に着けている男性俳優は、女性として予測されるかもしれません。  
Amazon Rekognition を使用してジェンダーバイナリー予測を作成することは、特定のユーザーを確認せずに性別分布の集計統計を分析する必要があるユースケースに最適です。たとえば、ソーシャルメディアプラットフォームで男性と比較した女性のユーザーの割合。  
性別二者択一の予測を使用して、個人の権利、プライバシー、またはサービスへのアクセスに影響する決定を行うことはお勧めしません。

Amazon Rekognition は英語でラベルを返します。[Amazon Translate](https://aws.amazon.com/translate/) を使って、英語のラベルを [その他の言語](https://docs.aws.amazon.com/translate/latest/dg/what-is.html#language-pairs) に翻訳することができます。

以下の図では、Amazon Rekognition Image または Amazon Rekognition Video オペレーションの使用目的に応じて、必要なオペレーションを呼び出す順序を示しています。



![\[画像およびビデオ分析ワークフローを示す図。保存済みビデオ処理とストリーミングビデオ処理は個別に示されている。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/dg/images/LabelDetectionWorkflow.png)


## レスポンスオブジェクトのラベル付け
<a name="labels-details"></a>

### 境界ボックス
<a name="labels-details-bbox"></a>

Amazon Rekognition イメージおよび Amazon Rekognition Video は、車、家具、アパレル、またはペットなどの一般的なオブジェクトラベルの境界ボックスを返すことができます。境界ボックス情報は、それほど一般的ではないオブジェクトラベルを返しません。境界ボックスを使用して、画像内のオブジェクトの正確な位置を検出したり、検出された被写体のインスタンスを数えたり、境界ボックスのディメンションを使用して被写体のサイズを測定したりできます。

たとえば、次のイメージでは、Amazon Rekognition イメージは人物、スケートボード、駐車中の車、その他の情報の存在を検出することができます。Amazon Rekognition のイメージは、検出された人、および車や車輪などの他の検出されたオブジェクトの境界ボックスも返します。

![\[市街地の路上、駐車中の車の間で、スケートボードの技を披露している人物。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/dg/images/detect-scenes.jpg)


### 信頼スコア
<a name="labels-details-image-conf-score"></a>

Amazon Rekognition Video および Amazon Rekognition Image は、Amazon Rekognition で検出された各ラベルの精度がどの程度信頼できるかを示す割合のスコアも表示します。

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

Amazon Rekognition イメージおよび Amazon Rekognition Video は、ラベルを分類するために祖先ラベルの階層分類を使用します。たとえば、道路を横切って歩いている人は *Pedestrian* として検出される可能性があります。*Pedestrian* の親ラベルは *Person* です。これらのラベルは両方とも応答で返されます。すべての先祖ラベルが返され、指定されたラベルにはその親および他の先祖ラベルのリストが含まれます。たとえば、祖父母ラベルと曽祖父母ラベル (存在する場合) です。親ラベルを使用して、関連するラベルのグループを作成したり、1 つ以上の画像内の類似ラベルを照会したりできます。たとえば、すべての *Vehicles* に対するクエリは、ある画像から自動車を、別の画像からバイクを返す可能性があります。

### カテゴリ
<a name="labels-details-image-categories"></a>

Amazon Rekognition Image および Amazon Rekognition Video は、ラベルカテゴリに関する情報を返します。ラベルは、「車両と自動車」や「食品と飲料」のように、共通の機能やコンテキストに基づいて個々のラベルをグループ化するカテゴリの一部です。ラベルカテゴリは親カテゴリのサブカテゴリにすることができます。

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

Amazon Rekognition Image と Amazon Rekognition Video は、ラベルを返すだけでなく、ラベルに関連付けられているエイリアスをすべて返します。エイリアスとは、同じ意味を持つラベル、または返されるプライマリラベルと視覚的に置換可能なラベルです。例えば、「セルフォン」は「携帯電話」のエイリアスです。

以前のバージョンでは、Amazon Rekognition Image は「携帯電話」を含むプライマリラベル名と同じリストに「セルフォン」などのエイリアスを返していました。現在 Amazon Rekognition Image は、「エイリアス」というフィールドに「セルフォン」を返し、プライマリラベル名のリストに「携帯電話」を返すようになりました。アプリケーションが以前のバージョンの Rekognition によって返された構造に依存している場合、必要に応じて、イメージまたはビデオのラベル検出オペレーションによって返される現在のレスポンスを、すべてのラベルとエイリアスがプライマリラベルとして返される以前のレスポンス構造に変換します。

DetectLabels API (イメージ内のラベル検出用) からの現在のレスポンスを以前のレスポンス構造に変換する必要がある場合は、「[DetectLabels レスポンスの変換](labels-detect-labels-image.md#detectlabels-transform-response)」のコード例を参照してください。

GetLabelDetection API (保存されているビデオのラベル検出用) からの現在のレスポンスを以前のレスポンス構造に変換する必要がある場合は、「[GetLabelDetection レスポンスの変換](labels-detecting-labels-video.md#getlabeldetection-transform-response)」のコード例を参照してください。

### イメージプロパティ
<a name="labels-details-image-properties"></a>

Amazon Rekognition Image は、イメージ全体の画質 (鮮明度、明るさ、コントラスト) に関する情報を返します。イメージの前景と背景の鮮明度と明るさに関する情報も返されます。イメージプロパティを使用して、イメージ全体、前景、背景、および境界ボックスを持つオブジェクトのドミナントカラーを検出することもできます。

![\[市街地の路上に駐車されている緑色の車の画像。車は境界ボックスで囲まれている。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/dg/images/car_bb.png)


 以下は、処理中のイメージの DetectLabels オペレーションのレスポンスに含まれる ImageProperties データの例です。

![\[画像全体、前景、背景、および境界ボックスで囲まれたサンプル物体の主要な色と画質メトリクスを示す表。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/dg/images/image_properties_table.png)


イメージプロパティは Amazon Rekognition Video では使用できません。

### モデルのバージョン
<a name="labels-details-image-model-version"></a>

Amazon Rekognition イメージおよび Amazon Rekognition Video は、いずれもイメージまたは保存されたビデオ内のラベルを検出するために使用されたラベル検出モデルのバージョンを返します。

### 包含フィルターと除外フィルター
<a name="labels-details-filters"></a>

Amazon Rekognition Image および Amazon Rekognition Video ラベル検出オペレーションによって返された結果をフィルタリングできます。ラベルとカテゴリのフィルタリング条件を指定して結果をフィルタリングします。ラベルフィルターには、包含フィルターと除外フィルターがあります。

`DetectLabels` を使用して得られた結果のフィルタリングの詳細については、「[イメージ内のラベルの検出](labels-detect-labels-image.md)」を参照してください。

`GetLabelDetection` によって得られた結果のフィルタリングの詳細については、「[ビデオ内のラベルの検出](labels-detecting-labels-video.md)」を参照してください。

### 結果のソートと集計
<a name="labels-details-sorting-aggregating"></a>

特定の Amazon Rekognition Video オペレーションから得られた結果は、タイムスタンプとビデオセグメントに従ってソートおよび集計できます。ラベル検出ジョブまたはコンテンツモデレーションジョブの結果を、`GetLabelDetection` または `GetContentModeration` を使用して取得する場合、`SortBy` および `AggregateBy` 引数を使用して結果の返し方を指定できます。`SortBy` を `TIMESTAMP` または `NAME` (ラベル名) と一緒に使用したり、`TIMESTAMPS` または `SEGMENTS` を AggregateBy 引数と一緒に使用したりできます。

# イメージ内のラベルの検出
<a name="labels-detect-labels-image"></a>

[DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html) オペレーションを使用して、イメージ内のラベル (オブジェクトと概念) を検出し、イメージのプロパティに関する情報を取得できます。イメージプロパティには、前景や背景の色、イメージの鮮明度、明るさ、コントラストなどの属性が含まれます。イメージ内のラベルのみ、イメージプロパティのみ、またはその両方を取得できます。例については、[Amazon S3 バケットに保存されたイメージの分析](images-s3.md)を参照してください。

次の例では AWS SDKs と を使用して AWS CLI を呼び出します`DetectLabels`。`DetectLabels` オペレーションからのレスポンスの詳細については、「[DetectLabels のレスポンス](#detectlabels-response)」を参照してください。

**イメージ内のラベルを検出するには**

1. まだ実行していない場合:

   1. `AmazonRekognitionFullAccess` と `AmazonS3ReadOnlyAccess` のアクセス権限を持つユーザーを作成または更新します。詳細については、「[ステップ 1: AWS アカウントを設定してユーザーを作成する](setting-up.md#setting-up-iam)」を参照してください。

   1. と AWS SDKs をインストール AWS CLI して設定します。詳細については、「[ステップ 2: AWS CLI と AWS SDKsを設定する](setup-awscli-sdk.md)」を参照してください。

1. 1 つ以上のオブジェクト (樹木、家、ボートなど) が含まれているイメージを S3 バケットにアップロードします。イメージは、*.jpg* 形式または *.png* 形式にする必要があります。

   手順については、[Amazon Simple Storage Service 入門ガイド](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)の「*Amazon S3 へのオブジェクトのアップロード*」を参照してください。

1. 以下の例を使用して、`DetectLabels` オペレーションを呼び出します。

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

   この例では、入力イメージ内で検出されたラベルのリストを表示します。`bucket` および `photo` の値は、ステップ 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 ]

   この例では、`detect-labels`　CLI オペレーションの JSON 出力を表示します。`bucket` および `photo` の値は、ステップ 2 で使用した Amazon S3 バケット名とイメージ名に置き換えます。`profile-name` の値を自分のデベロッパープロファイル名に置き換えます。

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

   Windows デバイスで CLI にアクセスする場合は、パーサーエラーの発生に対処するため、一重引用符の代わりに二重引用符を使用し、内側の二重引用符をバックスラッシュ (\$1) でエスケープします。例として以下を参照してください。

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

   この例では、入力イメージ内で検出されたラベルを表示します。関数 `main` で、`bucket` および `photo` の値は、ステップ 2 で使用した Amazon S3 バケット名とイメージ名に置き換えます。Rekognition セッションを作成する行の `profile_name` の値を、自分のデベロッパープロファイル名に置き換えます。

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

   この例では、入力イメージ内で検出されたラベルのリストを表示します。`bucket` および `photo` の値は、ステップ 2 で使用した Amazon S3 バケット名とイメージ名に置き換えます。

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

   この例では、入力イメージ内で検出されたラベルのリストを表示します。`bucket` および `photo` の値は、ステップ 2 で使用した Amazon S3 バケット名とイメージ名に置き換えます。

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

   この例では、入力イメージ内で検出されたラベルのリストを表示します。`bucket` および `photo` の値は、ステップ 2 で使用した Amazon S3 バケット名とイメージ名に置き換えます。Rekognition セッションを作成する行の `profile_name` の値を、自分のデベロッパープロファイル名に置き換えます。

   TypeScript 定義を使用している場合は、`import AWS from 'aws-sdk'` の代わりに`const AWS = require('aws-sdk')` Node.js でプログラムを実行するようになります。詳細については、[AWS JavaScriptのSDK](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) をご覧ください。構成の設定方法によっては、`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 ]

   このコードは、 AWS Documentation SDK サンプル GitHub リポジトリから取得されます。詳しい事例は [こちら](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 オペレーションのリクエスト
<a name="detectlabels-request"></a>

`DetectLabel` への入力はイメージです。この JSON 入力の例では、ソースイメージを Amazon S3 バケットからロードします。`MaxLabels` はレスポンスで返すラベルの最大数です。`MinConfidence` は Amazon Rekognition イメージが検出済みラベルの精度で保持しなければならない必要最小限の信頼度であり、それのためにレスポンスで返されます。

Features では、返されるイメージの 1 つ以上の特徴を指定でき、`GENERAL_LABELS` と `IMAGE_PROPERTIES` を選択できます。`GENERAL_LABELS` を含めると、入力イメージで検出されたラベルが返され、`IMAGE_PROPERTIES` を含めるとイメージの色と品質を確認できるようになります。

Settings では、返されるアイテムを `GENERAL_LABELS` と `IMAGE_PROPERTIES` 機能の両方でフィルターできます。ラベルには、包含フィルターと除外フィルターを使用できます。特定のラベル、個別のラベル、またはラベルカテゴリ別にフィルタリングすることもできます。
+ LabelInclusionFilters - レスポンスに含めるラベルを指定できます。
+ LabelExclusionFilters - レスポンスから除外するラベルを指定できます。
+ LabelCategoryInclusionFilters - レスポンスに含めるラベルカテゴリを指定できます。
+ LabelCategoryExclusionFilters - レスポンスから除外するラベルカテゴリを指定できます。

 また、必要に応じて包含フィルターと除外フィルターを組み合わせて、一部のラベルやカテゴリを除外したり、含めたりすることもできます。

`IMAGE_PROPERTIES` は、イメージのドミナントカラーや、鮮明度、明るさ、コントラストなどの品質属性を指します。`IMAGE_PROPERTIES` の検出時に、`MaxDominantColors` パラメータを使用して、返されるドミナントカラーの最大数を指定できます (デフォルトは 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 のレスポンス
<a name="detectlabels-response"></a>

`DetectLabels` からのレスポンスは、イメージ内で検出されたラベルとラベルの検出に使用された信頼度の配列です。

以下に、`DetectLabels` からのレスポンス例を示します。以下のサンプルレスポンスには、GENERAL\$1LABELS に対して返される次のようなさまざまな属性が含まれています。
+ 名前 - 検出されたラベルの名前 この例では、オペレーションによって「携帯電話」というラベルの付いたオブジェクトが検出されました。
+ 信頼度 - 各ラベルには信頼度が関連付けられています。この例では、ラベルの信頼度は 99.36% でした。
+ 親 - 検出されたラベルの祖先ラベルです。この例では、「携帯電話」というラベルには「電話」という親ラベルが 1 つあります。
+ エイリアス - ラベルに含まれている可能があるエイリアスの情報 この例では、「携帯電話」ラベルに「セルフォン」というエイリアスが含まれている可能性があります。
+ カテゴリ - 検出されたラベルが属するラベルカテゴリ この例では、「テクノロジーとコンピューティング」です。

共通オブジェクトラベルに対するレスポンスは、入力画像上のラベルの位置に対する境界ボックス情報を含みます。例えば、Person ラベルには、2 つの境界ボックスを含むインスタンス配列があります。これらは、画像内で検出された 2 人の人物の位置です。

レスポンスには IMAGE\$1PROPERTIES に関する属性も含まれています。IMAGE\$1PROPERTIES 機能によって提供される属性は以下のとおりです。
+ 品質 - 入力イメージの鮮明度、明るさ、コントラストに関する情報です。スコアは 0～100 です。品質で評価されるのは、イメージ全体、イメージの背景と前景 (可能な場合) です。ただし、コントラストで評価されるのはイメージ全体のみです。鮮明度と明るさでは、背景と前景も評価に含まれます。
+  ドミナントカラー - イメージ内のドミナントカラーの配列です。ドミナントカラーはそれぞれ、簡略化された色名、CSS カラーパレット、RGB 値、16 進コードで記述されます。
+  前景 - 入力イメージの前景のドミナントカラー、鮮明度、明るさに関する情報です。
+  背景 - 入力イメージの背景のドミナントカラー、鮮明度、明るさに関する情報です。

GENERAL\$1LABELS と IMAGE\$1PROPERTIES を入力パラメータとして一緒に使用すると、Amazon Rekognition Image は境界ボックスを持つオブジェクトのドミナントカラーも返します。

フィールド `LabelModelVersion` には `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"
}
```

## DetectLabels レスポンスの変換
<a name="detectlabels-transform-response"></a>

DetectLabels API を使用する場合、プライマリラベルとエイリアスの両方が同じリストに含まれていた古い API のレスポンス構造を模倣したレスポンス構造が必要になることがあります。

以下は、[DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html) からの現在の API レスポンスの例です。

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

以下は、[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" 
                }
             ]
         },
]
```

必要に応じて、現在のレスポンスを古いレスポンスの形式に従うように変換できます。次のサンプルコードを使用して、最新の API レスポンスを以前の API レスポンス構造に変換できます。

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

次のコードサンプルは、DetectLabels API からの現在のレスポンスを変換する方法を示しています。以下のコードサンプルでは、*EXAMPLE\$1INFERENCE\$1OUTPUT* の値を、実行した DetectLabels オペレーションの出力に置き換えることができます。

```
from copy import deepcopy

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

#Latest API response sample
EXAMPLE_INFERENCE_OUTPUT = {
    "Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Aliases": [
                {
                    "Name": "Cell Phone"
                }
            ],
            "Instances":[
                {
                    "BoundingBox":{
                        "Height":0.1549897,
                        "Width":0.07747964,
                        "Top":0.50858885,
                        "Left":0.00018205095
                    },
                    "Confidence":98.401276
                }
            ]
        },
        {
            "Name": "Urban",
            "Confidence": 99.99982,
            "Categories": [
                "Colors and Visual Composition"
            ]
        }
    ]
}

def expand_aliases(inferenceOutputsWithAliases):

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

        inferenceOutputsWithAliases[LABEL_KEY].extend(expandInferenceOutputs)

    return inferenceOutputsWithAliases


if __name__ == "__main__":

    outputWithExpandAliases = expand_aliases(EXAMPLE_INFERENCE_OUTPUT)
    print(outputWithExpandAliases)
```

変換されたレスポンスの例を以下に示します。

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

------

# ビデオ内のラベルの検出
<a name="labels-detecting-labels-video"></a>

Amazon Rekognition Video では、ビデオ内のラベル (オブジェクトと概念) を検出して、ラベルが検出された時刻を表示できます。SDK のコード例については、「[Java または Python を使用した、Amazon S3 バケットに保存されたビデオの分析 (SDK)](video-analyzing-with-sqs.md)」を参照してください。 AWS CLI 例については、「」を参照してください[を使用したビデオの分析 AWS Command Line Interface](video-cli-commands.md)。

Amazon Rekognition Video のラベル検出は、非同期オペレーションです。ビデオ内のラベルの検出を開始するには、[StartLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartlabelDetection.html) を呼び出します。

Amazon Rekognition Video は、ビデオ分析の完了ステータスを Amazon Simple Notification Service トピックに発行します。ビデオ分析が成功したら、[GetLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetLabelDetection.html) を呼び出して検出されたラベルを取得します。ビデオ分析の API オペレーションの詳細については、「[Amazon Rekognition Video オペレーションを呼び出す](api-video.md)」を参照してください。

## StartLabelDetection リクエスト
<a name="getlabeldetection-operation-request"></a>

以下に `StartLabelDetection` オペレーションのリクエストの例を示します。Amazon S3 バケットに保存されたビデオを使用して `StartLabelDetection` オペレーションを行います。リクエスト JSON の例では、Amazon S3 バケットとビデオ名が `MinConfidence`、`Features`、`Settings`、`NotificationChannel` と共に指定されています。

`MinConfidence` は、Amazon Rekognition Video がレスポンスで返すことができるようにするための、検出されたラベル、またはインスタンスの境界ボックス (検出された場合) の精度に対する最小限の信頼度です。

`Features` では、GENERAL\$1LABELS をレスポンスの一部として返すように指定できます。

`Settings` では、GENERAL\$1LABELS で返されるアイテムをフィルタリングできます。ラベルには、包含フィルターと除外フィルターを使用できます。特定のラベル、個別のラベル、またはラベルカテゴリ別にフィルタリングすることもできます。
+ `LabelInclusionFilters` - レスポンスに含めるラベルを指定するために使用します。
+ `LabelExclusionFilters` - レスポンスから除外するラベルを指定するために使用します。
+ `LabelCategoryInclusionFilters` - レスポンスに含めるラベルカテゴリを指定するために使用します。
+ `LabelCategoryExclusionFilters` - レスポンスから除外するラベルカテゴリを指定するために使用します。

また、必要に応じて包含フィルターと除外フィルターを組み合わせて、一部のラベルやカテゴリを除外したり、含めたりすることもできます。

`NotificationChannel` は、Amazon Rekognition Video がラベル検出オペレーションの完了ステータスを公開する Amazon SNS トピックの ARN です。`AmazonRekognitionServiceRole` 権限ポリシーを使用している場合、Amazon SNS トピックには、Rekognition で始まるトピック名が必要です。

以下は、フィルターを含む JSON 形式の `StartLabelDetection` リクエストの例です。

```
{
    "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 オペレーションレスポンス
<a name="getlabeldetection-operation-response"></a>

`GetLabelDetection` は、ビデオ内で検出されたラベルに関する情報が含まれた配列 (`Labels`) を返します。配列は、時間または `SortBy` パラメータを指定したとき検出されたラベルでソートできます。また、`AggregateBy` パラメータを使用してレスポンス項目の集計方法を選択することもできます。

次は、`GetLabelDetection` の JSON レスポンス例です。レスポンスで、以下の点に注意してください。
+ **並べ替え順** – 返されるラベルの配列は時刻別にソートされます。ラベル別に並べ替えるには、`GetLabelDetection` の `SortBy` 入力パラメータに `NAME` を指定します。ビデオ内でラベルが複数回表示されている場合、([LabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_LabelDetection.html)) 要素のインスタンスが複数存在しています。既定の並べ替え順序は `TIMESTAMP` で、副次的な並べ替え順序は `NAME` です。
+ **ラベル情報** – `LabelDetection` 配列要素には ([ラベル](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Label.html)) オブジェクトが含まれ、そこにはラベル名と、Amazon Rekognition が検出したラベルの精度に対する信頼度が含まれています。`Label` オブジェクトには、ラベルの階層分類と、一般的なラベルの境界ボックス情報も含まれます。`Timestamp` は、ラベルが検出された時間であり、ビデオの開始時刻からの経過ミリ秒数として定義されます。

  ラベルに関連付けられているカテゴリやエイリアスに関する情報も返されます。ビデオ `SEGMENTS` ごとに集計された結果では、`StartTimestampMillis`、`EndTimestampMillis`、`DurationMillis` 構造が返され、それぞれセグメントの開始時間、終了時間、持続時間を定義します。
+ **集計** — 結果が返されたときの集計方法を指定します。デフォルトでは `TIMESTAMPS` によって集計されます。また、`SEGMENTS` による集計を選択することもできます。この方法では、時間枠の結果が集計されます。`SEGMENTS` による集計の場合、境界ボックス付きの検出されたインスタンスに関する情報は返されません。このセグメント中に検出されたラベルのみが返されます。
+ **ページング情報** – この例では、ラベル検出情報が記載された 1 ページを示しています。`GetLabelDetection` の `MaxResults` 入力パラメータには、返す `LabelDetection` オブジェクトの数を指定できます。結果が `MaxResults` を超える場合、`GetLabelDetection` は次のページの結果を取得するためのトークン (`NextToken`) を返します。詳細については、「[Amazon Rekognition Video の分析結果を取得する](api-video.md#api-video-get)」を参照してください。
+ **ビデオの情報** – レスポンスには、`VideoMetadata` から返される情報のページごとにビデオ形式に関する情報 (`GetLabelDetection`) が含まれます。

以下は、TIMESTAMPS による集計を含む JSON 形式の GetLabelDetection レスポンスのサンプルです。

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

以下は、SEGMENTS による集計を含む JSON 形式の GetLabelDetection レスポンスのサンプルです。

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

## GetLabelDetection レスポンスの変換
<a name="getlabeldetection-transform-response"></a>

GetLabelDetection API オペレーションを実行して結果を取得する場合、プライマリラベルとエイリアスの両方が同じリストに含まれていた古い API レスポンス構造を模倣したレスポンス構造が必要になることがあります。

前のセクションにある JSON レスポンスの例には、GetLabelDetection からの API レスポンスの現在の形式が表示されています。

次の例は、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
    }
}
```

必要に応じて、現在のレスポンスを古いレスポンスの形式に従うように変換できます。次のサンプルコードを使用して、最新の API レスポンスを以前の API レスポンス構造に変換できます。

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

# ストリーミングビデオイベント内のラベルの検出
<a name="streaming-video-detect-labels"></a>

Amazon Rekognition Video を使用して、ストリーミングビデオ内のラベルを検出できます。これを行うには、ストリーミングビデオの分析を開始および管理するためのストリームプロセッサ ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)) を作成します。

Amazon Rekognition Video は、Amazon Kinesis Video Streams を使用して、ビデオストリームを受信し処理します。ストリームプロセッサを作成するときに、ストリームプロセッサで検出する内容を選択します。人、パッケージ、ペット、または人とパッケージを選択できます。分析結果は、Amazon S3 バケットと Amazon SNS 通知に出力されます。Amazon Rekognition Video はビデオ内の人物の存在を検出しますが、その人物が特定の個人であるかどうかは検出しないことに注意してください。ストリーミングビデオのコレクションから顔を検索するには、「[ストリーミングビデオのコレクション内での顔検索](collections-streaming.md)」を参照してください。

ストリーミングビデオで Amazon Rekognition Video を使用するには、アプリケーションに以下が必要です。
+ Amazon Rekognition Video にストリーミングビデオを送信する Kinesis ビデオストリーム。詳細については、「[Amazon Kinesis Video Streams デベロッパーガイド](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html)」を参照してください。
+ ストリーミングビデオの分析を管理するための Amazon Rekognition Video ストリームプロセッサ。詳細については、「[Amazon Rekognition Video ストリームプロセッサオペレーションの概要](streaming-video.md#using-rekognition-video-stream-processor)」を参照してください。
+ Amazon S3 バケット。Amazon Rekognition Video はセッション出力を S3 バケットに公開します。出力には、対象の人物またはオブジェクトが初めて検出されたイメージフレームが含まれます。S3 バケットを所有している必要があります。
+ Amazon Rekognition Video がスマートアラートとセッション終了の概要を公開する Amazon SNS トピック。

**Topics**
+ [Amazon Rekognition Video と Amazon Kinesis のリソースを設定する](streaming-labels-setting-up.md)
+ [ストリーミングビデオイベントに対するラベル検出オペレーションの呼び出し](streaming-labels-detection.md)

# Amazon Rekognition Video と Amazon Kinesis のリソースを設定する
<a name="streaming-labels-setting-up"></a>

 次の手順では、ストリーミングビデオ内のラベルの検出に使用する Kinesis ビデオストリームとその他のリソースをプロビジョニングするためのステップを説明します。

## 前提条件
<a name="streaming-video-prerequisites"></a>

この手順を実行するには、 をインストール AWS SDK for Java する必要があります。詳細については、「[Amazon Rekognition の開始方法](getting-started.md)」を参照してください。使用する AWS アカウントには、Amazon Rekognition API へのアクセス権限が必要です。詳細については、*IAM ユーザーガイド*の「[Amazon Rekognition で定義されるアクション](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions)」を参照してください。

**ビデオストリーム内のラベルを検出するには (AWS SDK)**

1. Amazon S3 バケットを作成する。バケット名と、使用するキープレフィックスをメモします。この情報は後で使用します。

1. Amazon SNS トピックを作成します。これを使用して、ビデオストリームで対象オブジェクトが初めて検出されたときに通知を受け取れます。トピックの Amazon リソースネーム (ARN) をメモします。詳細については、Amazon SNS デベロッパーガイドの「[Amazon SNS トピックを作成する](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html)」を参照してください。

1. エンドポイントを Amazon SNS トピックにサブスクライブします。詳細については、Amazon SNS デベロッパーガイドの「[Amazon SNS トピックへサブスクライブする](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html)」を参照してください。

1. [Kinesis ビデオストリームを作成](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html)して、そのストリームの Amazon リソースネーム (ARN) をメモします。

1. まだ作成していない場合は、Amazon Rekognition Video に Kinesis ビデオストリーム、S3 バケット、Amazon SNS トピックへのアクセス権を付与する IAM サービスロールを作成します。詳細については、「[ラベル検出ストリームプロセッサへのアクセス権を付与する](#streaming-labels-giving-access)」を参照してください。

その後、[ラベル検出ストリームプロセッサを作成し](streaming-labels-detection.md#streaming-video-create-labels-stream-processor)、選択したストリームプロセッサ名を使用して[ストリームプロセッサを起動](streaming-labels-detection.md#streaming-video-start-labels-stream-processor)できます。

**注記**  
ストリームプロセッサは、Kinesis ビデオストリームにメディアを取り込めることを確認した後に起動してください。

## カメラの向きとセットアップ
<a name="streaming-labels-camera-setup"></a>

Amazon Rekognition Video ストリーミングビデオイベントでは、Kinesis ビデオストリームでサポートされているすべてのカメラをサポートできます。最良の結果を得るには、カメラを地面と 0～45 度に配置することをお勧めします。カメラは標準的な直立状態にある必要があります。例えば、フレーム内に人物がいる場合、人物の向きは垂直で、頭は足よりも高い位置にある必要があります。

## ラベル検出ストリームプロセッサへのアクセス権を付与する
<a name="streaming-labels-giving-access"></a>

 AWS Identity and Access Management (IAM) サービスロールを使用して、Amazon Rekognition Video に Kinesis ビデオストリームへの読み取りアクセスを許可します。これを行うには、IAM ロールを使用して、Amazon Rekognition Video に Amazon S3 バケットと Amazon SNS トピックへのアクセス権を付与します。

Amazon Rekognition Video が既存の Amazon SNS トピック、Amazon S3 バケット、Kinesis ビデオストリームにアクセスできるようにするアクセス許可ポリシーを作成できます。を使用した手順については AWS CLI、step-by-step「」を参照してください[AWS CLI ラベル検出 IAM ロールをセットアップするための コマンド](#streaming-labels-giving-access-cli)。

**Amazon Rekognition Video がラベル検出のためにリソースにアクセスできるようにするには**

1. [[IAM JSON ポリシーエディターを使用して新しい許可ポリシーを作成し](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor)]、次のポリシーを使用します。`kvs-stream-name` を Kinesis ビデオストリームの名前に置き換えます。`topicarn` は、使用する Amazon SNS トピックの Amazon リソースネーム (ARN) に置き換え、`bucket-name` は Amazon S3 バケットの名前に置き換えます。

1. [IAM サービスロールを作成する](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console) または、既存の IAM サービスロールを更新します。次の情報を使用して、IAM サービスロールを作成します。

   1. サービス名の **Rekognition** を選択します。

   1. サービスロールのユースケースの **Rekognition** を選択します。

   1. 手順 1 で作成したアクセス権ポリシーを添付します。

1. サービスロールの ARN をメモしておきます。ビデオ分析オペレーションを実行する前に、ストリームプロセッサを作成する必要があります。

1. (オプション) 独自の AWS KMS キーを使用して S3 バケットに送信されるデータを暗号化する場合は、IAM ロールに次のステートメントを追加する必要があります。(これはキーポリシー用に作成した IAM ロールであり、使用するカスタマーマネージドキーに対応します。)

   ```
       
               {
                          "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 ラベル検出 IAM ロールをセットアップするための コマンド
<a name="streaming-labels-giving-access-cli"></a>

まだ設定していない場合は、認証情報 AWS CLI を使用して をセットアップして設定します。

に次のコマンドを入力して AWS CLI 、ラベル検出に必要なアクセス許可を持つ IAM ロールを設定します。

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

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

1. 以下の内容を含む信頼関係ポリシーファイル (assume-role-rekognition.json など) を作成します。

------
#### [ 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. 通知を受け取りたい SNS トピックの名前が「AmazonRekognition」プレフィックスで始まっていない場合は、次のポリシーを追加してください。

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

1. S3 バケットに送信されるデータを暗号化するために独自の AWS KMS キーを使用する場合は、使用するカスタマーマネージドキーのキーポリシーを更新します。

   1. kms\$1key\$1policy.json ファイルを作成します。

      ```
      {
      "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` を含めます。KMS\$1KEY\$1ID は、作成した KMS キー ID に置き換えてください。

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

# ストリーミングビデオイベントに対するラベル検出オペレーションの呼び出し
<a name="streaming-labels-detection"></a>

Amazon Rekognition Video は、ストリーミングビデオ内の人または関連オブジェクトを検出し、検出されると通知を送信できます。ラベル検出ストリームプロセッサを作成するときは、Amazon Rekognition Video で検出したいラベルを選択します。ラベルには、人、パッケージとペット、または人、パッケージ、ペットがあります。検出したい特定のラベルのみを選択してください。これにより、関連するラベルのみが通知を作成します。ビデオ情報を保存するタイミングを決定するオプションを設定し、フレーム内で検出されたラベルに基づいて追加の処理を行えます。

リソースをセットアップした後、ストリーミングビデオ内のラベルを検出するプロセスは次のとおりです。

1. ストリームプロセッサを作成する

1. ストリームプロセッサを開始する

1. 対象オブジェクトが検出されると、対象の各オブジェクトの最初の出現に対して Amazon SNS 通知を受け取ります。

1. ストリームプロセッサは、`MaxDurationInSeconds` で指定された時間が経過すると停止します。

1. イベントの概要が記載された最終的な Amazon SNS 通知を受け取ります。

1. Amazon Rekognition Video は、セッションの詳細な概要を S3 バケットに公開します。

**Topics**
+ [Amazon Rekognition Video ラベル検出ストリームプロセッサを作成する](#streaming-video-create-labels-stream-processor)
+ [Amazon Rekognition Video ラベル検出ストリームプロセッサの起動](#streaming-video-start-labels-stream-processor)
+ [ラベル検出結果の分析](#streaming-video-labels-stream-processor-results)

## Amazon Rekognition Video ラベル検出ストリームプロセッサを作成する
<a name="streaming-video-create-labels-stream-processor"></a>

ストリーミングビデオを分析する前に、Amazon Rekognition Video ストリームプロセッサ ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)) を作成します。

対象となるラベルや人を検出するストリームプロセッサを作成する場合は、Kinesis ビデオストリーム (`Input`)、Amazon S3 バケット情報 (`Output`)、Amazon SNS トピック ARN (`StreamProcessorNotificationChannel`) を入力として指定します。Amazon S3 バケットに送信されるデータを暗号化する KMS キー ID を指定することもできます。人、パッケージと人、またはペット、人、パッケージなど、`Settings` で検出する内容を指定します。Amazon Rekognition が `RegionsOfInterest` を使用してモニタリングするフレーム内の箇所を指定することもできます。`CreateStreamProcessor` リクエストに関する JSON の例を次に示します。

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

`MinConfidence` 値は、ストリームプロセッサの `ConnectedHomeSettings` を指定するときに変更できます。`MinConfidence` は 0～100 の数値で、アルゴリズムの予測がどの程度確実であるかを示します。例えば、信頼度が 90 の `person` の通知は、アルゴリズムが、その人物がビデオに存在することを確信していることを意味します。信頼値が 10 の場合は、人物が存在する可能性があるということです。通知を受ける頻度に応じて、`MinConfidence` を 0～100 の任意の値に設定できます。例えば、Rekognition がビデオフレームにパッケージが含まれていると確信した場合にのみ通知を受け取りたい場合は、`MinConfidence` を 90 に設定できます。

`MinConfidence ` は、デフォルトで 50 に設定されます。アルゴリズムを最適化して精度を高めたい場合は、`MinConfidence` を 50 より大きい値に設定できます。これにより、通知を受け取る回数は少なくなりますが、各通知の信頼性は高まります。アルゴリズムを最適化してリコールを高めたい場合は、`MinConfidence` を 50 未満に設定すれば、より多くの通知を受け取れます。

## Amazon Rekognition Video ラベル検出ストリームプロセッサの起動
<a name="streaming-video-start-labels-stream-processor"></a>

`CreateStreamProcessor` で指定したストリームプロセッサの名前を使用して [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) を呼び出し、ストリーミングビデオの分析を開始します。ラベル検出ストリームプロセッサで `StartStreamProcessor` オペレーションを実行する場合は、開始情報と停止情報を入力して処理時間を決定します。

ストリームプロセッサが起動すると、ラベル検出ストリームプロセッサの状態は次のように変化します。

1. `StartStreamProcessor` を呼び出すと、ラベル検出ストリームのプロセッサの状態は `STOPPED` または `FAILED` から `STARTING` に変化します。

1. ラベル検出ストリームプロセッサが実行されている間は、状態は `STARTING` になります。

1. ラベル検出ストリームプロセッサの実行が終了すると、状態は `STOPPED` または `FAILED` になります。

`StartSelector` は、処理を開始する Kinesis ストリームの開始点を指定します。KVS Producer のタイムスタンプまたは KVS フラグメント番号を使用できます。詳細については、「[Fragment](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_reader_Fragment.html)」を参照してください。

**注記**  
KVS Producer のタイムスタンプを使用する場合は、時間をミリ秒単位で入力する必要があります。

`StopSelector` は、ストリームの処理を停止するタイミングを指定します。ビデオを処理する最大時間を指定できます。デフォルトでは、最大継続時間が 10 秒に設定されています。個々の KVS フラグメントのサイズによっては、実際の処理時間が最大継続時間より少し長くなる場合があることに注意してください。フラグメントの終端で最大継続時間に達したか、それを超えた場合、処理時間は停止します。

`StartStreamProcessor` リクエストに関する JSON の例を次に示します。

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

ストリームプロセッサが正常に起動した場合は、HTTP 200 レスポンスが返されます。空の JSON 本文が含まれています。

## ラベル検出結果の分析
<a name="streaming-video-labels-stream-processor-results"></a>

Amazon Rekognition Video がラベル検出ストリームプロセッサから通知を公開する方法は 3 つあります。オブジェクト検出イベントの Amazon SNS 通知、セッション終了の概要に関する Amazon SNS 通知、詳細な Amazon S3 バケットレポートです。
+ オブジェクト検出イベントの Amazon SNS 通知 

  ビデオストリームでラベルが検出されると、オブジェクト検出イベントの Amazon SNS 通知を受け取ります。Amazon Rekognition は、ビデオストリームで対象オブジェクトまたは人物が初めて検出されたときに通知を公開します。通知には、検出されたラベルのタイプ、信頼度、ヒーローイメージへのリンクなどの情報が含まれています。また、検出された人物またはオブジェクトのトリミングされたイメージや検出タイムスタンプも含まれています。この通知の形式は次のとおりです。

  ```
  {"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
      }
  }
  ```
+ Amazon SNS セッション終了の概要

  ストリーム処理セッションが終了すると、Amazon SNS 通知も送信されます。この通知には、セッションのメタデータがリスト表示されます。また、処理されたストリームの継続時間などの詳細情報が含まれています。この通知の形式は次のとおりです。

  ```
  {"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 バケットレポート

  Amazon Rekognition Video は、ビデオ分析オペレーションの詳細な推論結果を、`CreateStreamProcessor` オペレーションで提供された Amazon S3 バケットに公開します。これらの結果には、対象のオブジェクトや人物が初めて検出されたイメージフレームが含まれています。

  フレームは S3 パス ObjectKeyPrefix/StreamProcessorName/SessionId/*service\$1determined\$1unique\$1path* で入手できます。このパスでは、**LabelKeyPrefix** はお客様指定のオプション引数、**StreamProcessorName** はストリームプロセッサリソースの名前、**SessionId** はストリーム処理セッションの固有の ID です。これらは状況に応じて置き換えてください。

# カスタムラベルの検出
<a name="labels-detecting-custom-labels"></a>

Amazon Rekognition カスタムラベルにより、ビジネスニーズに固有のイメージ内のオブジェクトやシーン (ロゴやエンジニアリング機械部品など) を識別できます。詳細については、[[Amazon Rekognition カスタムラベル デベロッパー ガイド](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html)] の [*Amazon Rekognition カスタムラベルについて*] を参照してください。