

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 객체 및 개념 감지
<a name="labels"></a>

이 섹션에서는 Amazon Rekognition Image 및 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/ko_kr/rekognition/latest/dg/images/LabelDetectionWorkflow.png)


## 레이블 응답 객체
<a name="labels-details"></a>

### 경계 상자
<a name="labels-details-bbox"></a>

Amazon Rekognition Image 및 Amazon Rekognition Video는 차량, 가구, 의류, 반려동물 등 일반적 객체 레이블에 대해 경계 상자를 반환할 수 있습니다. 경계 상자 정보는 이보다 일반적이지 않은 객체 레이블에 대해서는 반환되지 않습니다. 경계 상자를 사용하여 이미지에서 객체의 정확한 위치를 찾거나, 감지된 객체의 인스턴스 수를 계산하거나, 경계 상자 치수를 사용하여 객체의 크기를 측정할 수 있습니다.

예를 들어 다음 이미지에서 Amazon Rekognition Image는 사람의 존재, 스케이트보드, 주차된 차량 및 기타 정보를 감지할 수 있습니다. Amazon Rekognition Image는 감지된 사람과 자동차나 바퀴와 같은 기타 감지된 객체에 대해서도 경계 상자를 반환합니다.

![\[도시 거리의 주차된 차량 사이에서 스케이트보드 스턴트를 하는 사람.\]](http://docs.aws.amazon.com/ko_kr/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 Image와 Amazon Rekognition Video는 상위 레이블의 계층적 분류 체계를 사용하여 레이블을 분류합니다. 예를 들어 도로를 횡단하는 사람이 *보행자*로 감지될 수 있습니다. *보행자*의 부모 레이블은 *인물*입니다. 응답에서 두 레이블이 모두 반환됩니다. 모든 상위 레이블이 반환되고, 지정된 레이블이 부모 및 기타 상위 레이블의 목록을 포함합니다. 예를 들어, 존재할 경우 조부모 및 증조부모 레이블이 포함됩니다. 부모 레이블을 사용하여 관련된 레이블의 그룹을 만들고 하나 이상의 이미지에서 비슷한 레이블을 쿼리하도록 허용할 수 있습니다. 예를 들어 모든 *차량*을 쿼리하면 한 이미지에서 자동차가 반환되고 다른 이미지에서 오토바이가 반환될 수 있습니다.

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

Amazon Rekognition Image 및 Amazon Rekognition Video는 레이블 카테고리에 대한 정보를 반환합니다. 레이블은 '차량 및 자동차', '식음료'와 같이 공통 기능 및 맥락에 기반하여 개별 레이블을 그룹화하는 카테고리의 일부입니다. 레이블 카테고리는 상위 카테고리의 하위 카테고리일 수 있습니다.

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

Amazon Rekognition Image와 Amazon Rekognition Video는 레이블을 반환하는 것 외에도 레이블과 연결된 모든 별칭을 반환합니다. 별칭은 의미가 같은 레이블 또는 반환된 기본 레이블과 시각적으로 서로 바꿀 수 있는 레이블을 말합니다. 예를 들어, 'Cell Phone'은 'Mobile Phone'의 별칭입니다.

이전 버전에서는 Amazon Rekognition Image가 'Mobile Phone'을 포함하는 동일한 기본 레이블 이름 목록에서 'Cell Phone'과 같은 별칭을 반환했습니다. Amazon Rekognition Image는 이제 “별칭” 필드에 ‘Cell Phone’을, 기본 레이블 이름 목록에 'Mobile Phone'을 반환합니다. 애플리케이션이 이전 버전의 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/ko_kr/rekognition/latest/dg/images/car_bb.png)


 다음은 현재 이미지에 대한 DetectLabels 작업의 응답에 포함된 ImageProperties 데이터의 예입니다.

![\[전체 이미지, 전경, 배경 및 경계 상자가 있는 예제 객체에 대한 주요 색상과 이미지 품질 지표를 보여주는 표입니다.\]](http://docs.aws.amazon.com/ko_kr/rekognition/latest/dg/images/image_properties_table.png)


Amazon Rekognition Video에서는 이미지 속성을 사용할 수 없습니다.

### 모델 버전
<a name="labels-details-image-model-version"></a>

Amazon Rekognition Image 및 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 CLI 및 AWS SDKs를 설치하고 구성합니다. 자세한 내용은 [2단계: AWS CLI 및 AWS SDKs 설정](setup-awscli-sdk.md) 단원을 참조하십시오.

1. 나무, 집, 보트 등과 같은 객체가 한 개 이상 있는 이미지를 S3 버킷에 업로드합니다. 이미지는 *.jpg* 또는 *.png* 형식이어야 합니다.

   이에 관한 지침은 *Amazon Simple Storage Service 사용 설명서*에서 [Amazon S3에 객체 업로드](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)를 참조하세요.

1. 다음 예제를 사용하여 `DetectLabels` 작업을 호출합니다.

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

   이 예제는 입력 이미지에서 감지된 레이블 목록을 표시합니다. `bucket` 및 `photo`의 값을 2단계에서 사용한 Amazon S3 버킷과 이미지의 이름으로 바꿉니다.

   ```
   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 정의를 사용하는 경우 Node.js로 프로그램을 실행하려면 `const AWS = require('aws-sdk')` 대신 `import AWS from 'aws-sdk'`를 사용해야 할 수도 있습니다. 자세한 내용은 [AWS SDK for Javascript](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 설명서 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 Image가 감지된 레이블을 응답에 반환하기 위해 충족해야 하는 최소 정확성 신뢰도 수준입니다.

Features로 반환하려는 이미지의 특성을 하나 이상 지정할 수 있으며, 이를 통해 `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에 대해 반환되는 다양한 속성이 포함되어 있습니다.
+ Name - 탐지된 레이블의 이름. 이 예제에서는 작업을 통해 Mobile Phone 레이블이 붙은 객체를 감지했습니다.
+ Confidence - 각 레이블에는 연결된 신뢰도 수준이 있습니다. 이 예제에서 레이블에 대한 신뢰도는 99.36% 였습니다.
+ Parents - 탐지된 레이블의 상위 레이블입니다. 이 예제에서 Mobile Phone 레이블에는 Phone이라는 상위 레이블이 있습니다.
+ Aliases - 레이블에 있을 수 있는 별칭에 대한 정보. 이 예제에서 Mobile Phone 레이블에는 Cell Phone이라는 별칭이 있을 수 있습니다.
+ Categories - 탐지된 레이블이 속하는 레이블 카테고리입니다. 이 예제에서는 Technology and Computing입니다.

일반적 객체 레이블에 대한 응답은 입력 이미지 상의 레이블 위치에 대한 경계 상자 정보를 포함합니다. 예를 들어 인물 레이블은 두 개의 경계 상자를 포함하는 인스턴스 배열을 갖습니다. 이들은 이미지에서 감지된 두 사람의 위치입니다.

응답에는 IMAGE\$1PROPERTIES와 관련된 속성도 포함됩니다. IMAGE\$1PROPERTIES 기능이 제공하는 속성은 다음과 같습니다.
+ Quality - 입력 이미지의 선명도, 밝기 및 대비에 대한 정보로, 0에서 100 사이의 점수가 매겨집니다. 전체 이미지 및 가능한 경우 이미지의 배경 및 전경에 대한 품질이 보고됩니다. 그러나 대비는 전체 이미지에 대해서만 보고되는 반면 선명도 및 밝기는 배경 및 전경에 대해서도 보고됩니다.
+  Dominant Color - 이미지의 주 색상 배열입니다. 각각의 주 색상은 단순화된 색상 이름, CSS 색상 팔레트, RGB 값 및 16진수 코드로 기술됩니다.
+  Foreground - 입력 이미지 전경의 주 색상, 선명도 및 밝기에 대한 정보입니다.
+  Background - 입력 이미지 배경의 주 색상, 선명도 및 밝기에 대한 정보입니다.

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 응답 예입니다. 응답에서 다음에 유의하십시오.
+ **Sort order** - 시간별로 정렬된 반환된 레이블의 배열. 레이블별로 정렬하려면, `GetLabelDetection`에서 `SortBy` 입력 파라미터에 `NAME`를 지정하십시오. 레이블이 비디오에 여러 번 나오면 ([LabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_LabelDetection.html))요소의 여러 인스턴스가 있습니다. 기본 정렬 순서는 `TIMESTAMP`이고 보조 정렬 순서는 `NAME`입니다.
+ **레이블 정보** - `LabelDetection` 배열 요소에는 ([Label](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Label.html))객체가 포함되어 있는데 이는 감지된의 레이블 이름과 Amazon Rekognition이 그에 대해 가지는 정확성 신뢰도를 포함합니다. 또한 `Label` 객체에는 레이블의 계층적 분류와 일반 레이블의 경우에는 경계 상자 정보가 포함됩니다. `Timestamp`는 비디오 시작부터 레이블이 감지될 때까지 지난 밀리초 단위의 시간입니다.

  레이블과 관련된 모든 카테고리 또는 별칭에 관한 정보도 반환됩니다. 비디오 `SEGMENTS`별로 집계된 결과의 경우 세그먼트의 시작 시간, 종료 시간, 지속 시간을 각각 정의하는 `StartTimestampMillis`, `EndTimestampMillis`, `DurationMillis` 구조가 반환됩니다.
+ **Aggregation** - 결과가 반환될 때 집계되는 방식을 지정합니다. 기본값은 `TIMESTAMPS` 기준 집계입니다. 일정 기간 동안의 결과를 집계하는 `SEGMENTS` 집계 기준을 선택할 수도 있습니다. `SEGMENTS` 기준으로 집계할 경우 경계 상자가 있는 감지된 인스턴스에 대한 정보는 반환되지 않습니다. 세그먼트 내에서 감지된 레이블만 반환됩니다.
+ **페이징 정보** - 이 예제는 레이블 감지 정보의 페이지 하나를 보여줍니다. `GetLabelDetection`의 `MaxResults` 입력 파라미터에서 반환하는 `LabelDetection` 객체의 개수를 지정할 수 있습니다. `MaxResults` 보다 많은 결과가 존재할 경우 `GetLabelDetection`은 결과의 다음 페이지를 가져올 때 사용되는 토큰(`NextToken`)을 반환합니다. 자세한 내용은 [Amazon Rekognition Video 분석 결과 가져오기](api-video.md#api-video-get) 단원을 참조하십시오.
+ **비디오 정보** - 응답에는`GetLabelDetection`에서 반환된 정보의 각 페이지에 있는 비디오 형식(`VideoMetadata`)에 관한 정보가 포함되어 있습니다.

다음은 타임스탬프 기준으로 집계된 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
    }
}
```

다음은 세그먼트 기준으로 집계된 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 Video Streams에서 지원하는 모든 카메라를 지원할 수 있습니다. 최상의 결과를 얻으려면 카메라를 지면에서 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 비디오 스트림에 액세스할 수 있도록 허용하는 권한 정책을 생성할 수 있습니다. 를 사용하는 step-by-step 절차는 단원을 AWS CLI참조하십시오[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)하고 다음 정책을 사용합니다. `topicarn`을 Kinesis 비디오 스트림의 이름으로, `kvs-stream-name`을 사용하려는 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 으로를 설정하고 구성합니다.

에 다음 명령을 입력하여 레이블 감지에 필요한 권한을 가진 IAM 역할을 AWS CLI 설정합니다.

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. Amazon 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`)을 입력으로 제공하세요. KMS 키 ID를 제공하여 S3 버킷으로 전송된 데이터를 암호화할 수도 있습니다. 사람, 패키지 및 사람, 또는 반려동물, 사람, 패키지 등 `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
        }
      ]
    }
  ]
}
```

참고로 스트림 프로세서에 `ConnectedHomeSettings`를 지정하면 `MinConfidence` 값을 변경할 수 있습니다. `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 생산자 타임스탬프 또는 KVS 조각 번호를 사용할 수 있습니다. 자세한 내용은 [조각](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_reader_Fragment.html)을 참조하세요.

**참고**  
KVS 생산자 타임스탬프를 사용하는 경우 시간을 밀리초 단위로 입력해야 합니다.

`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가 레이블 탐지 스트림 프로세서로부터 알림을 게시하는 방법에는 세 가지가 있습니다. 객체 감지 이벤트에 대한 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 Custom Labels는 이미지에서 비즈니스 요구 사항과 관련된 객체와 장면(예: 로고 또는 엔지니어링 기계 부품)을 식별할 수 있습니다. 자세한 내용은 *Amazon Rekognition Custom Labels 개발자 안내서*의 [Amazon Rekognition Custom Labels란 무엇인가요?](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html)를 참조하세요.