

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

# イメージ付きのトレーニングデータセットとテストデータセットの作成
<a name="md-create-dataset"></a>

1 つのデータセットを使用するプロジェクトから始めることも、個別のトレーニングデータセットとテストデータセットを持つプロジェクトから始めることもできます。1 つのデータセットから始めると、Amazon Rekognition Custom Labels はトレーニング中にデータセットを分割して、プロジェクトのトレーニングデータセット (80%) とテストデータセット (20%) を作成します。Amazon Rekognition Custom Labels にトレーニングとテストに使用するイメージを決定させる場合は、1 つのデータセットから始めてください。トレーニング、テスト、パフォーマンスのチューニングを完全に制御するには、トレーニングデータセットとテストデータセットを分けてプロジェクトを開始することをお勧めします。

以下のいずれかの場所からイメージをインポートすることにより、プロジェクトのトレーニングデータセットとテストデータセットを作成できます。
+ [Amazon S3 バケットからの画像のインポート](md-create-dataset-s3.md)
+ [ローカルコンピュータからの画像のインポート](md-create-dataset-computer.md)
+ [マニフェストファイルを使用した画像のインポート](md-create-dataset-ground-truth.md)
+ [既存のデータセットからのコンテンツのコピー](md-create-dataset-existing-dataset.md)

トレーニングデータセットとテストデータセットを分けてプロジェクトを開始する場合は、データセットごとに異なるソースの場所を使用できます。

イメージのインポート元によっては、イメージにラベルが付いていない場合があります。例えば、ローカルコンピュータからインポートされたイメージにはラベルは付きません。Amazon SageMaker AI Ground Truth マニフェストファイルからインポートされたイメージにはラベルが付けられます。Amazon Rekognition Custom Labels コンソールを使用して、ラベルの追加、変更、割り当てを行うことができます。詳細については、「[イメージにラベルを付ける](md-labeling-images.md)」を参照してください。

イメージのアップロード時にエラーが発生する、イメージが見つからない、イメージにラベルが付いていない場合は、「[失敗したモデルトレーニングのデバッグ](tm-debugging.md)」を参照してください。

データセットの詳細については、「[データセットの管理](managing-dataset.md)」を参照してください。

## トレーニングデータセットとテストデータセットの作成 (SDK)
<a name="cd-create-dataset-sdk"></a>

 AWS SDK を使用して、トレーニングデータセットとテストデータセットを作成できます。

`CreateDataset` オペレーションでは、リソースの分類と管理を目的として、新しいデータセットの作成時にオプションでタグを指定できます。

### トレーニングデータセット
<a name="cd-create-training-dataset"></a>

 AWS SDK を使用して、次の方法でトレーニングデータセットを作成できます。
+ [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset) は、ユーザーが提供する Amazon SageMaker 形式のマニフェストファイルとともに使用します。詳細については、「[マニフェストファイルの作成](md-create-manifest-file.md)」を参照してください。サンプルコードについては、「[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk)」を参照してください。
+ `CreateDataset` を使用して、既存の Amazon Rekognition Custom Labels データセットをコピーします。サンプルコードについては、「[既存のデータセットを使用したデータセットの作成 (SDK)](md-create-dataset-existing-dataset-sdk.md)」を参照してください。
+ `CreateDataset` で空のデータセットを作成し、後で [UpdateDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UpdateDatasetEntries) でデータセットエントリを追加します。空のデータセットを作成する方法については、「[データセットをプロジェクトに追加する](md-add-dataset.md)」を参照してください。データセットにイメージを追加する方法については、「[イメージの追加 (SDK)](md-add-images.md#md-add-images-sdk)」を参照してください。モデルをトレーニングする前に、データセットエントリを追加する必要があります。

### テストデータセット
<a name="cd-create-test-dataset"></a>

 AWS SDK を使用して、次の方法でテストデータセットを作成できます。
+ [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset) は、ユーザーが提供する Amazon SageMaker 形式のマニフェストファイルとともに使用します。詳細については、「[マニフェストファイルの作成](md-create-manifest-file.md)」を参照してください。サンプルコードについては、「[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk)」を参照してください。
+ `CreateDataset` を使用して、既存の Amazon Rekognition Custom Labels データセットをコピーします。サンプルコードについては、「[既存のデータセットを使用したデータセットの作成 (SDK)](md-create-dataset-existing-dataset-sdk.md)」を参照してください。
+ `CreateDataset` で空のデータセットを作成し、後で `UpdateDatasetEntries` でデータセットエントリを追加します。空のデータセットを作成する方法については、「[データセットをプロジェクトに追加する](md-add-dataset.md)」を参照してください。データセットにイメージを追加する方法については、「[イメージの追加 (SDK)](md-add-images.md#md-add-images-sdk)」を参照してください。モデルをトレーニングする前に、データセットエントリを追加する必要があります。
+ トレーニングデータセットとテストデータセットを分割します。まず、`CreateDataset` で空のテストデータセットを作成します。次に、[DistributeDataSetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries) を呼び出して、トレーニングデータセットエントリの 20% をテストデータセットに移動します。空のデータセットを作成する方法については、「[データセットをプロジェクトに追加する (SDK)](md-add-dataset.md#md-add-dataset-sdk)」を参照してください。トレーニングデータセットを分割する方法については、「[トレーニングデータセットの分散 (SDK)](md-distributing-datasets.md)」を参照してください。

# Amazon S3 バケットからの画像のインポート
<a name="md-create-dataset-s3"></a>

イメージは Amazon S3 バケットからインポートされます。コンソールバケット、または AWS アカウント内の別の Amazon S3 バケットを使用できます。コンソールバケットを使用している場合、必要な権限は既に設定されています。コンソールバケットを使用していない場合は、「[外部の Amazon S3 バケットへのアクセス](su-console-policy.md#su-external-buckets)」を参照してください。

**注記**  
 AWS SDK を使用して、Amazon S3 バケット内のイメージから直接データセットを作成することはできません。代わりに、イメージのソースロケーションを参照するマニフェストファイルを作成してください。詳細については、[マニフェストファイルを使用した画像のインポート](md-create-dataset-ground-truth.md)を参照してください。

データセットの作成中に、画像を含むフォルダの名前に基づいて画像にラベル名を割り当てることを選択できます。フォルダは、データセット作成時に **S3 フォルダの場所**で指定した Amazon S3 フォルダパスの子である必要があります。データセットの作成については、「[S3 バケットのイメージをインポートしてデータセットを作成する](#cd-procedure)」を参照してください。

例えば、Amazon S3 バケットに次のようなフォルダ構造があるとします。Amazon S3 フォルダの場所を *S3-bucket/alexa-devices* として指定した場合、*echo* フォルダ内のイメージには、*echo* というラベルが割り当てられます。同様に、*echo-dot* フォルダ内のイメージには *echo-dot* というラベルが割り当てられます。より深い子フォルダの名前は、画像のラベル付けには使用されません。代わりに、Amazon S3 フォルダの場所の適切な子フォルダが使用されます。例えば、*white-echo-dots* フォルダ内のイメージには *echo-dot* というラベルが割り当てられます。S3 フォルダの場所 (*Alexa-devices*) のレベルにあるイメージにはラベルは割り当てられていません。

 フォルダ構造がより深いフォルダであれば、S3 フォルダのより深い場所を指定してイメージにラベルを付けることができます。例えば、*S3-bucket/alexa-devices/echo-dot* を指定した場合、*white-echo-dot* フォルダ内のイメージには *white-echo-dot* というラベルが付けられます。*echo* など、指定した S3 フォルダの場所以外のイメージはインポートされません。

```
S3-bucket
└── alexa-devices
    ├── echo
    │   ├── echo-image-1.png
    │   └── echo-image-2.png
    │   ├── .
    │   └── .
    └── echo-dot
        ├── white-echo-dot
        │   ├── white-echo-dot-image-1.png
        │   ├── white-echo-dot-image-2.png
        │
        ├── echo-dot-image-1.png
        ├── echo-dot-image-2.png
        ├── .
        └── .
```

現在の AWS リージョンでコンソールを初めて開いたときは、Amazon Rekognition によって作成された Amazon Amazon S3 バケット (コンソールバケット) を使用することをお勧めします。使用している Amazon S3 バケットがコンソールバケットと異なる (外部) 場合、データセットの作成中に、コンソールから適切な権限を設定するように求められます。詳細については、「[ステップ 2: Amazon Rekognition Custom Labels コンソールのアクセス許可をセットアップする](su-console-policy.md)」を参照してください。

## S3 バケットのイメージをインポートしてデータセットを作成する
<a name="cd-procedure"></a>

次の手順では、コンソール S3 バケットに保存されているイメージを使用してデータセットを作成する方法を示しています。イメージには、保存されているフォルダの名前で自動的にラベルが付けられます。

イメージをインポートした後は、データセットのギャラリーページからのイメージの追加、ラベルの割り当て、境界ボックスの追加を行うことができます。詳細については、「[イメージにラベルを付ける](md-labeling-images.md)」を参照してください。<a name="cd-upload-s3-bucket"></a>

**Amazon Simple Storage Service バケットにイメージをアップロードします。**

1. ローカルファイルシステムにフォルダを作成します。*Alexa-devices* などのフォルダ名を使用してください。

1. 作成したフォルダ内に、使用する各ラベルの名前を付けたフォルダを作成します。例えば、*echo* や *echo-dot* などです。フォルダの構成は次のようにします。

   ```
   alexa-devices
   ├── echo
   │   ├── echo-image-1.png
   │   ├── echo-image-2.png
   │   ├── .
   │   └── .
   └── echo-dot
       ├── echo-dot-image-1.png
       ├── echo-dot-image-2.png
       ├── .
       └── .
   ```

1. ラベルに対応するイメージを、同じラベル名のフォルダに配置します。

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) で Amazon S3 コンソールを開きます。

1. *初回セットアップ*時に Amazon Rekognition Custom Labels が作成した Amazon S3 バケット (コンソールバケット) に、ステップ 1 で作成した[フォルダを追加](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)します。詳細については、「[Amazon Rekognition Custom Labels プロジェクトの管理](managing-project.md)」を参照してください。

1. Amazon Rekognition コンソールを [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) で開きます。

1. **[カスタムラベルを使用]** を選択します。

1. **[開始方法]** を選択します。

1. 左側のナビゲーションペインで、**[プロジェクト]** を選択します。

1. 「**プロジェクト**」ページで、データセットを追加したいプロジェクトを選択します。プロジェクトの詳細ページが表示されます。

1. **[データセットを作成]** を選択します。「**データセットを作成**」ページが表示されます。

1. **[設定の開始]** で、**[1 つのデータセットで開始]** または **[トレーニングデータセットで開始]** を選択します。より高品質のモデルを作成するには、トレーニングデータセットとテストデータセットを別々に始めることを推奨します。

------
#### [ Single dataset ]

   1. **[トレーニングデータセットの詳細]** セクションで、**[S3 バケットからのイメージのインポート]** を選択します。

   1. **[トレーニングデータセットの詳細]**セクションで、**[イメージソース設定]** セクションにステップ 13～15 の情報を入力します。

------
#### [ Separate training and test datasets ]

   1. **[トレーニングデータセットの詳細]** セクションで、**[S3 バケットからのイメージのインポート]** を選択します。

   1. **[トレーニングデータセットの詳細]**セクションで、**[イメージソース設定]** セクションにステップ 13～15 の情報を入力します。

   1. **[テストデータセットの詳細]** セクションで、**[S3 バケットからのイメージのインポート]** を選択します。

   1. **[テストデータセットの詳細]**セクションで、**[イメージソース設定]** セクションにステップ 13～15 の情報を入力します。

------

1. **[Amazon S3 バケットから画像をインポート]** を選択します。

1. **S3 URI** には、Amazon S3 バケットの場所とフォルダのパスを入力します。

1. **[フォルダに基づいて画像にラベルを自動的にアタッチ]** を選択します。

1. **[データセットを作成]** を選択します。プロジェクトのデータセットページが開きます。

1. ラベルの追加または変更の必要がある場合は、[イメージにラベルを付ける](md-labeling-images.md) を実行してください。

1. 「[モデルのトレーニング (コンソール)](training-model.md#tm-console)」の手順に従って、モデルをトレーニングします。

# ローカルコンピュータからの画像のインポート
<a name="md-create-dataset-computer"></a>

イメージは、コンピュータから直接ロードされます。同時にアップロードできる画像は、30 枚までです。

アップロードしたイメージにはラベルは付いていません。詳細については、「[イメージにラベルを付ける](md-labeling-images.md)」を参照してください。アップロードするイメージが多い場合は、Amazon S3 バケットの使用を検討してください。詳細については、「[Amazon S3 バケットからの画像のインポート](md-create-dataset-s3.md)」を参照してください。

**注記**  
 AWS SDK を使用してローカルイメージを含むデータセットを作成することはできません。代わりに、マニフェストファイルを作成し、Amazon S3 バケットにイメージをアップロードします。詳細については、「[マニフェストファイルを使用した画像のインポート](md-create-dataset-ground-truth.md)」を参照してください。

**ローカルコンピュータ上の画像を使用してデータセットを作成するには (コンソール)**

1. Amazon Rekognition コンソールを [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) で開きます。

1. **[カスタムラベルを使用]** を選択します。

1. **[開始方法]** を選択します。

1. 左側のナビゲーションペインで、**[プロジェクト]** を選択します。

1. 「**プロジェクト**」ページで、データセットを追加したいプロジェクトを選択します。プロジェクトの詳細ページが表示されます。

1. **[データセットを作成]** を選択します。「**データセットを作成**」ページが表示されます。

1. **[設定の開始]** で、**[1 つのデータセットで開始]** または **[トレーニングデータセットで開始]** を選択します。より高品質のモデルを作成するには、トレーニングデータセットとテストデータセットを別々に始めることを推奨します。

------
#### [ Single dataset ]

   1. **[トレーニングデータセットの詳細]** セクションで、**[コンピュータから画像をアップロード]** を選択します。

   1. **[データセットを作成]** を選択します。

   1. データセットページで、**[画像を追加]** を選択します。

   1. コンピュータファイルからデータセットにアップロードする画像を選択します。画像をドラッグするか、ローカルコンピュータからアップロードする画像を選択できます。

   1. **[画像をアップロード]** を選択します。

------
#### [ Separate training and test datasets ]

   1. **[トレーニングデータセット詳細]** セクションで、**[コンピュータから画像をアップロード]** を選択します。

   1. **[テストデータセット詳細]** セクションで、**[コンピュータから画像をアップロード]** を選択します。
**注記**  
トレーニングデータセットとテストデータセットは、異なる画像ソースを持つことができます。

   1. **[データセットを作成]** を選択します。プロジェクトのデータセットページが表示され、それぞれのデータセットの**[トレーニング]** タブと**[テスト]** タブが表示されます。

   1. **[アクション]** を選択し、**[トレーニングデータセットに画像を追加]** をクリックします。

   1. データセットにアップロードする画像を選択します。画像をドラッグするか、ローカルコンピュータからアップロードする画像を選択できます。

   1. **[画像をアップロード]** を選択します。

   1. ステップ 5e ～ 5g を繰り返します。ステップ 5e で、**[アクション]** を選択します。**[テストデータセットに画像を追加]** をクリックします。

------

1. 「[イメージにラベルを付ける](md-labeling-images.md)」の手順に従って、画像にラベルを付けます。

1. 「[モデルのトレーニング (コンソール)](training-model.md#tm-console)」の手順に従って、モデルをトレーニングします。

# マニフェストファイルを使用した画像のインポート
<a name="md-create-dataset-ground-truth"></a>

Amazon SageMaker AI Ground Truth 形式のマニフェストファイルを使用してデータセットを作成できます。Amazon SageMaker AI Ground Truth ジョブからマニフェストファイルを使用できます。イメージとラベルが SageMaker AI Ground Truth マニフェストファイルの形式でない場合は、SageMaker AI 形式のマニフェストファイルを作成し、それを使用してラベル付きイメージをインポートできます。

`CreateDataset` オペレーションが更新されて、新しいデータセットの作成時にオプションでタグを指定できるようになりました。タグは、リソースの分類と管理に使用できるキーと値のペアです。

**Topics**
+ [SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)](#md-create-dataset-ground-truth-console)
+ [SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](#md-create-dataset-ground-truth-sdk)
+ [データセット作成リクエスト](#create-dataset-ground-truth-request)
+ [Amazon SageMaker AI Ground Truth ジョブを使用したイメージのラベル付け](md-create-dataset-ground-truth-job.md)
+ [マニフェストファイルの作成](md-create-manifest-file.md)
+ [マニフェストファイルでの画像レベルラベルのインポート](md-create-manifest-file-classification.md)
+ [マニフェストファイル内のオブジェクトのローカリゼーション](md-create-manifest-file-object-detection.md)
+ [マニフェストファイルの検証ルール](md-create-manifest-file-validation-rules.md)
+ [他のデータセット形式をマニフェストファイルに変換する](md-converting-to-sm-format.md)

## SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)
<a name="md-create-dataset-ground-truth-console"></a>

次の手順では、SageMaker AI Ground Truth 形式のマニフェストファイルを使用してデータセットを作成する方法を示します。

1. 次のいずれかの方法で、トレーニングデータセットのマニフェストファイルを作成します。
   + 「」の手順に従って、SageMaker AI GroundTruth ジョブを使用してマニフェストファイルを作成します[Amazon SageMaker AI Ground Truth ジョブを使用したイメージのラベル付け](md-create-dataset-ground-truth-job.md)。
   + 「[マニフェストファイルの作成](md-create-manifest-file.md)」の手順に従って、独自のマニフェストファイルを作成します。

   テストデータセットを作成する場合は、ステップ 1 を繰り返してテストデータセットを作成します。

1. Amazon Rekognition コンソールを [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) で開きます。

1. **[カスタムラベルを使用]** を選択します。

1. **[開始方法]** を選択します。

1. 左側のナビゲーションペインで、**[プロジェクト]** を選択します。

1. 「**プロジェクト**」ページで、データセットを追加したいプロジェクトを選択します。プロジェクトの詳細ページが表示されます。

1. **[データセットを作成]** を選択します。「**データセットを作成**」ページが表示されます。

1. **[設定の開始]** で、**[1 つのデータセットで開始]** または **[トレーニングデータセットで開始]** を選択します。より高品質のモデルを作成するには、トレーニングデータセットとテストデータセットを別々に始めることを推奨します。

------
#### [ Single dataset ]

   1. **[トレーニングデータセット詳細]** セクションで、**[SageMaker Ground Truth によってラベル付けされた画像をインポート]** を選択します。

   1. **[マニフェストファイルの場所]** には、ステップ 1 で作成したマニフェストファイルの場所を入力します。

   1. **[データセットを作成]** を選択します。プロジェクトのデータセットページが開きます。

------
#### [ Separate training and test datasets ]

   1. **[トレーニングデータセット詳細]** セクションで、**[SageMaker Ground Truth によってラベル付けされた画像をインポート]** を選択します。

   1. **[マニフェストファイルの場所]**には、ステップ 1 で作成したトレーニングデータセットのマニフェストファイルの場所を入力します。

   1. **[テストデータセット詳細]** セクションで、**[SageMaker Ground Truth によってラベル付けされた画像をインポート]** を選択します。
**注記**  
トレーニングデータセットとテストデータセットは、異なる画像ソースを持つことができます。

   1. **[マニフェストファイルの場所]**には、ステップ 1 で作成したテストデータセットのマニフェストファイルの場所を入力します。

   1. **[データセットを作成]** を選択します。プロジェクトのデータセットページが開きます。

------

1. ラベルの追加または変更の必要がある場合は、[イメージにラベルを付ける](md-labeling-images.md) を実行してください。

1. 「[モデルのトレーニング (コンソール)](training-model.md#tm-console)」の手順に従って、モデルをトレーニングします。

## SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成
<a name="md-create-dataset-ground-truth-sdk"></a>

次の手順では、[CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset) API を使用してマニフェストファイルからトレーニングデータセットまたはテストデータセットを作成する方法を示しています。

[SageMaker AI Ground Truth ジョブ](md-create-dataset-ground-truth-job.md)からの出力などの既存のマニフェストファイルを使用することも、独自の[マニフェストファイル](md-create-manifest-file.md)を作成することもできます。

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

1. 次のいずれかの方法で、トレーニングデータセットのマニフェストファイルを作成します。
   + 「」の手順に従って、SageMaker AI GroundTruth ジョブを使用してマニフェストファイルを作成します[Amazon SageMaker AI Ground Truth ジョブを使用したイメージのラベル付け](md-create-dataset-ground-truth-job.md)。
   + 「[マニフェストファイルの作成](md-create-manifest-file.md)」の手順に従って、独自のマニフェストファイルを作成します。

   テストデータセットを作成する場合は、ステップ 2 を繰り返してテストデータセットを作成します。

1. 次のサンプルコードを使用して、トレーニングデータセットとテストデータセットを作成します。

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

   次のコードを使用してデータセットを作成します。以下に置き換えます:
   + `project_arn` - テストデータセットを追加するプロジェクトの ARN。
   + `type` - 作成するデータセットのタイプ (トレーニングまたはテスト)
   + `bucket` - データセットのマニフェストファイルを含むバケット。
   + `manifest_file` - マニフェストファイルのパスとファイル名。

   ```
   aws rekognition create-dataset --project-arn project_arn \
     --dataset-type type \
     --dataset-source '{ "GroundTruthManifest": { "S3Object": { "Bucket": "bucket", "Name": "manifest_file" } } }' \
     --profile custom-labels-access
     --tags '{"key1": "value1", "key2": "value2"}'
   ```

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

   次の値を使用してデータセットを作成します。次のコマンドラインパラメータを指定します。
   + `project_arn` - テストデータセットを追加するプロジェクトの ARN。
   + `dataset_type` - 作成するデータセットのタイプ (`train` または `test`)。
   + `bucket` - データセットのマニフェストファイルを含むバケット。
   + `manifest_file` - マニフェストファイルのパスとファイル名。

   ```
   #Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   #PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
   
   import argparse
   import logging
   import time
   import json
   import boto3
   from botocore.exceptions import ClientError
   
   logger = logging.getLogger(__name__)
   
   def create_dataset(rek_client, project_arn, dataset_type, bucket, manifest_file):
       """
       Creates an Amazon Rekognition Custom Labels dataset.
       :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
       :param project_arn: The ARN of the project in which you want to create a dataset.
       :param dataset_type: The type of the dataset that you want to create (train or test).
       :param bucket: The S3 bucket that contains the manifest file.
       :param manifest_file: The path and filename of the manifest file.
       """
   
       try:
           #Create the project
           logger.info("Creating %s dataset for project %s",dataset_type, project_arn)
   
           dataset_type = dataset_type.upper()
   
           dataset_source = json.loads(
               '{ "GroundTruthManifest": { "S3Object": { "Bucket": "'
               + bucket
               + '", "Name": "'
               + manifest_file
               + '" } } }'
           )
   
           response = rek_client.create_dataset(
               ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
           )
   
           dataset_arn=response['DatasetArn']
   
           logger.info("dataset ARN: %s",dataset_arn)
   
           finished=False
           while finished is False:
   
               dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
   
               status=dataset['DatasetDescription']['Status']
               
               if status == "CREATE_IN_PROGRESS":
                   logger.info("Creating dataset: %s ",dataset_arn)
                   time.sleep(5)
                   continue
   
               if status == "CREATE_COMPLETE":
                   logger.info("Dataset created: %s", dataset_arn)
                   finished=True
                   continue
   
               if status == "CREATE_FAILED":
                   error_message = f"Dataset creation failed: {status} : {dataset_arn}"
                   logger.exception(error_message)
                   raise Exception (error_message)
                   
               error_message = f"Failed. Unexpected state for dataset creation: {status} : {dataset_arn}"
               logger.exception(error_message)
               raise Exception(error_message)
               
           return dataset_arn
      
       
       except ClientError as err:
           logger.exception("Couldn't create dataset: %s",err.response['Error']['Message'])
           raise
   
   def add_arguments(parser):
       """
       Adds command line arguments to the parser.
       :param parser: The command line parser.
       """
   
       parser.add_argument(
           "project_arn", help="The ARN of the project in which you want to create the dataset."
       )
   
       parser.add_argument(
           "dataset_type", help="The type of the dataset that you want to create (train or test)."
       )
   
       parser.add_argument(
           "bucket", help="The S3 bucket that contains the manifest file."
       )
       
       parser.add_argument(
           "manifest_file", help="The path and filename of the manifest file."
       )
   
   
   def main():
   
       logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
   
       try:
   
           #Get command line arguments.
           parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
           add_arguments(parser)
           args = parser.parse_args()
   
           print(f"Creating {args.dataset_type} dataset for project {args.project_arn}")
   
           #Create the dataset.
           session = boto3.Session(profile_name='custom-labels-access')
           rekognition_client = session.client("rekognition")
   
           dataset_arn=create_dataset(rekognition_client, 
               args.project_arn,
               args.dataset_type,
               args.bucket,
               args.manifest_file)
   
           print(f"Finished creating dataset: {dataset_arn}")
   
   
       except ClientError as err:
           logger.exception("Problem creating dataset: %s", err)
           print(f"Problem creating dataset: {err}")
   
   
   
   if __name__ == "__main__":
       main()
   ```

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

   次の値を使用してデータセットを作成します。次のコマンドラインパラメータを指定します。
   + `project_arn` - テストデータセットを追加するプロジェクトの ARN。
   + `dataset_type` - 作成するデータセットのタイプ (`train` または `test`)。
   + `bucket` - データセットのマニフェストファイルを含むバケット。
   + `manifest_file` - マニフェストファイルのパスとファイル名。

   ```
   /*
      Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
      SPDX-License-Identifier: Apache-2.0
   */
   
   package com.example.rekognition;
   
   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.CreateDatasetRequest;
   import software.amazon.awssdk.services.rekognition.model.CreateDatasetResponse;
   import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
   import software.amazon.awssdk.services.rekognition.model.DatasetSource;
   import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
   import software.amazon.awssdk.services.rekognition.model.DatasetType;
   import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
   import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
   import software.amazon.awssdk.services.rekognition.model.GroundTruthManifest;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.rekognition.model.S3Object;
   
   import java.util.logging.Level;
   import java.util.logging.Logger;
   
   public class CreateDatasetManifestFiles {
   
       public static final Logger logger = Logger.getLogger(CreateDatasetManifestFiles.class.getName());
   
       public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
               String bucket, String name) throws Exception, RekognitionException {
   
           try {
   
               logger.log(Level.INFO, "Creating {0} dataset for project : {1} from s3://{2}/{3} ",
                       new Object[] { datasetType, projectArn, bucket, name });
   
               DatasetType requestDatasetType = null;
   
               switch (datasetType) {
               case "train":
                   requestDatasetType = DatasetType.TRAIN;
                   break;
               case "test":
                   requestDatasetType = DatasetType.TEST;
                   break;
               default:
                   logger.log(Level.SEVERE, "Could not create dataset. Unrecognized dataset type: {0}", datasetType);
                   throw new Exception("Could not create dataset. Unrecognized dataset type: " + datasetType);
   
               }
   
               GroundTruthManifest groundTruthManifest = GroundTruthManifest.builder()
                       .s3Object(S3Object.builder().bucket(bucket).name(name).build()).build();
   
               DatasetSource datasetSource = DatasetSource.builder().groundTruthManifest(groundTruthManifest).build();
   
               CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
                       .datasetType(requestDatasetType).datasetSource(datasetSource).build();
   
               CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
   
               boolean created = false;
   
               do {
   
                   DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
                           .datasetArn(response.datasetArn()).build();
                   DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
   
                   DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
   
                   DatasetStatus status = datasetDescription.status();
   
                   logger.log(Level.INFO, "Creating dataset ARN: {0} ", response.datasetArn());
   
                   switch (status) {
   
                   case CREATE_COMPLETE:
                       logger.log(Level.INFO, "Dataset created");
                       created = true;
                       break;
   
                   case CREATE_IN_PROGRESS:
                       Thread.sleep(5000);
                       break;
   
                   case CREATE_FAILED:
                       String error = "Dataset creation failed: " + datasetDescription.statusAsString() + " "
                               + datasetDescription.statusMessage() + " " + response.datasetArn();
                       logger.log(Level.SEVERE, error);
                       throw new Exception(error);
   
                   default:
                       String unexpectedError = "Unexpected creation state: " + datasetDescription.statusAsString() + " "
                               + datasetDescription.statusMessage() + " " + response.datasetArn();
                       logger.log(Level.SEVERE, unexpectedError);
                       throw new Exception(unexpectedError);
                   }
   
               } while (created == false);
   
               return response.datasetArn();
   
           } catch (RekognitionException e) {
               logger.log(Level.SEVERE, "Could not create dataset: {0}", e.getMessage());
               throw e;
           }
   
       }
   
       public static void main(String[] args) {
   
           String datasetType = null;
           String bucket = null;
           String name = null;
           String projectArn = null;
           String datasetArn = null;
   
           final String USAGE = "\n" + "Usage: " + "<project_arn> <dataset_type> <dataset_arn>\n\n" + "Where:\n"
                   + "   project_arn - the ARN of the project that you want to add copy the datast to.\n\n"
                   + "   dataset_type - the type of the dataset that you want to create (train or test).\n\n"
                   + "   bucket - the S3 bucket that contains the manifest file.\n\n"
                   + "   name - the location and name of the manifest file within the bucket.\n\n";
   
           if (args.length != 4) {
               System.out.println(USAGE);
               System.exit(1);
           }
   
           projectArn = args[0];
           datasetType = args[1];
           bucket = args[2];
           name = args[3];
   
           try {
   
               // Get the Rekognition client
               RekognitionClient rekClient = RekognitionClient.builder()
                   .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
                   .region(Region.US_WEST_2)
                   .build();
   
   
                // Create the dataset
               datasetArn = createMyDataset(rekClient, projectArn, datasetType, bucket, name);
   
               System.out.println(String.format("Created dataset: %s", datasetArn));
   
               rekClient.close();
   
           } catch (RekognitionException rekError) {
               logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
               System.exit(1);
           } catch (Exception rekError) {
               logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
               System.exit(1);
           }
   
       }
   
   }
   ```

------

1. ラベルの追加または変更の必要がある場合は、「[ラベルの管理 (SDK)](md-labels.md#md-labels-sdk)」を参照してください。

1. 「[モデルのトレーニング (SDK)](training-model.md#tm-sdk)」の手順に従って、モデルをトレーニングします。

## データセット作成リクエスト
<a name="create-dataset-ground-truth-request"></a>

 CreateDataset オペレーションリクエストの形式は以下のとおりです。

```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```

# Amazon SageMaker AI Ground Truth ジョブを使用したイメージのラベル付け
<a name="md-create-dataset-ground-truth-job"></a>

Amazon SageMaker AI Ground Truth では、選択したベンダー企業である Amazon Mechanical Turk のワーカー、またはラベル付き画像セットを作成できる機械学習を備えた内部のプライベートワークフォースを使用できます。Amazon Rekognition Custom Labels は、指定した Amazon S3 バケットから SageMaker AI Ground Truth マニフェストファイルをインポートします。

Amazon Rekognition Custom Labels は、次の SageMaker AI Ground Truth タスクをサポートしています。
+ [イメージ分類](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification.html)
+ [境界ボックス](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-bounding-box.html)

インポートするファイルは、イメージとマニフェストファイルです。マニフェストファイルには、インポートするイメージのラベルと境界ボックス情報が含まれています。

Amazon Rekognition には、イメージが保存されている Amazon S3 バケットにアクセスするためのアクセス許可が必要です。Amazon Rekognition Custom Labels によって設定されたコンソールバケットを使用している場合、必要なアクセス許可は既に設定されています。コンソールバケットを使用していない場合は、「[外部の Amazon S3 バケットへのアクセス](su-console-policy.md#su-external-buckets)」を参照してください。

## SageMaker AI Ground Truth ジョブを使用したマニフェストファイルの作成 (コンソール)
<a name="md-create-dataset-ground-truth-job-console"></a>

次の手順では、SageMaker AI Ground Truth ジョブでラベル付けされた画像を使用してデータセットを作成する方法を示します。ジョブ出力ファイルは Amazon Rekognition Custom Labels コンソールバケットに保存されます。<a name="create-dataset-procedure-ground-truth"></a>

**SageMaker AI Ground Truth ジョブでラベル付けされたイメージを使用してデータセットを作成するには (コンソール)**

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) で Amazon S3 コンソールを開きます。

1. コンソールバケットに、トレーニングイメージを保存する[フォルダを作成](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html)します。
**注記**  
コンソールバケットは、 AWS リージョンで Amazon Rekognition Custom Labels コンソールを初めて開いたときに作成されます。詳細については、「[Amazon Rekognition Custom Labels プロジェクトの管理](managing-project.md)」を参照してください。

1. 作成したフォルダに[イメージをアップロード](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)します。

1. コンソールバケットに、Ground Truth ジョブの出力を保存するフォルダを作成します。

1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) を開きます。

1. Ground Truth ラベリングジョブを作成します。ステップ 2 とステップ 4 で作成したフォルダの Amazon S3 URL が必要になります。詳細については、「[データラベリングに Amazon SageMaker Ground Truth を使用する](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html)」を参照してください。

1. ステップ 4 で作成したフォルダ内の `output.manifest` ファイルの場所を記録しておきます。このファイルは、サブフォルダ `Ground-Truth-Job-Name/manifests/output` に保存されている必要があります。

1. 「[SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console)」の手順に従って、アップロードしたマニフェストファイルを使用してデータセットを作成します。ステップ 8 では、**[マニフェストファイルの場所]** に、前のステップで記録しておいた場所の Amazon S3 URL を入力します。 AWS SDK を使用している場合は、 を実行します[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk)。

1. ステップ 1～6 を繰り返して、テストデータセットの SageMaker AI Ground Truth ジョブを作成します。

# マニフェストファイルの作成
<a name="md-create-manifest-file"></a>

SageMaker AI Ground Truth 形式のマニフェストファイルをインポートすることで、テストデータセットまたはトレーニングデータセットを作成できます。イメージが SageMaker AI Ground Truth マニフェストファイルではない形式でラベル付けされている場合は、次の情報を使用して SageMaker AI Ground Truth 形式のマニフェストファイルを作成します。

マニフェストファイルは [JSON Lines](http://jsonlines.org) 形式で、各行は画像のラベリング情報を表す完全な JSON オブジェクトです。Amazon Rekognition Custom Labels は、JSON 行を持つ SageMaker AI Ground Truth マニフェストを次の形式でサポートします。
+ [[分類ジョブ出力]](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class) - イメージにイメージレベルのラベルを追加する場合に使用します。イメージレベルのラベルは、イメージ上にあるシーン、概念、オブジェクト (オブジェクトの位置情報が不要な場合) のクラスを定義します。1 つのイメージには、複数のイメージレベルのラベルを付けることができます。詳細については、「[マニフェストファイルでの画像レベルラベルのインポート](md-create-manifest-file-classification.md)」を参照してください。
+ [[境界ボックスジョブ出力]](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) - イメージ上の 1 つ以上のオブジェクトのクラスと位置にラベルを付けるために使用します。詳細については、「[マニフェストファイル内のオブジェクトのローカリゼーション](md-create-manifest-file-object-detection.md)」を参照してください。

イメージレベルとローカリゼーション (境界ボックス) の JSON 行を同じマニフェストファイルに連結できます。

**注記**  
このセクションの JSON Lines の例は、読みやすいようにフォーマットされています。

マニフェストファイルをインポートすると、Amazon Rekognition Custom Labels は制限、構文、セマンティクスの検証ルールを適用します。詳細については、「[マニフェストファイルの検証ルール](md-create-manifest-file-validation-rules.md)」を参照してください。

マニフェストファイルで参照される画像は、同じ Amazon S3 バケットに配置する必要があります。マニフェストファイルは、イメージを保存する Amazon S3 バケットとは異なる Amazon S3 バケットに配置できます。JSON Lines の `source-ref` フィールドに画像の場所を指定します。

Amazon Rekognition には、イメージが保存されている Amazon S3 バケットにアクセスするためのアクセス許可が必要です。Amazon Rekognition Custom Labels によって設定されたコンソールバケットを使用している場合、必要なアクセス許可は既に設定されています。コンソールバケットを使用していない場合は、「[外部の Amazon S3 バケットへのアクセス](su-console-policy.md#su-external-buckets)」を参照してください。

**Topics**
+ [マニフェストファイルの作成](#md-create-manifest-file-console)

## マニフェストファイルの作成
<a name="md-create-manifest-file-console"></a>

次の手順で、トレーニングデータセットとテストデータセットを持つプロジェクトを作成します。データセットは、作成したトレーニングマニフェストファイルとテストマニフェストファイルから作成されます。

<a name="create-dataset-procedure-manifest-file"></a>

**SageMaker AI Ground Truth 形式のマニフェストファイルを使用してデータセットを作成するには (コンソール)**

1. コンソールバケットに、マニフェストファイルを保存する[フォルダを作成](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html)します。

1. コンソールバケットに、イメージを保存するフォルダを作成します。

1. 作成したフォルダに画像をアップロードします。

1. トレーニングデータセットの SageMaker AI Ground Truth 形式のマニフェストファイルを作成します。詳細については、「[マニフェストファイルでの画像レベルラベルのインポート](md-create-manifest-file-classification.md)」および「[マニフェストファイル内のオブジェクトのローカリゼーション](md-create-manifest-file-object-detection.md)」を参照してください。
**重要**  
各 JSON 行の `source-ref` フィールド値は、アップロードしたイメージにマッピングする必要があります。

1. テストデータセットの SageMaker AI Ground Truth 形式のマニフェストファイルを作成します。

1. 先ほど作成したフォルダに、[マニフェストファイルをアップロード](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)します。

1. マニフェストファイルの場所を記録しておきます。

1. 「[SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console)」の手順に従って、アップロードしたマニフェストファイルを使用してデータセットを作成します。ステップ 8 では、**[マニフェストファイルの場所]** に、前のステップで記録しておいた場所の Amazon S3 URL を入力します。 AWS SDK を使用している場合は、 を実行します[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk)。

# マニフェストファイルでの画像レベルラベルのインポート
<a name="md-create-manifest-file-classification"></a>

イメージレベルのラベル (ローカリゼーション情報を必要としないシーン、概念、またはオブジェクトでラベル付けされたイメージ) をインポートするには、SageMaker AI Ground Truth [分類ジョブ出力](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class)形式の JSON 行をマニフェストファイルに追加します。マニフェストファイルは、インポートする画像ごとに1 行以上の JSON Lines で構成されます。

**ヒント**  
マニフェストファイルの作成を簡易化するために、CSV ファイルからマニフェストファイルを作成する Python スクリプトを提供しています。詳細については、「[CSV ファイルからのマニフェストファイルの作成](ex-csv-manifest.md)」を参照してください。

**画像レベルラベルのマニフェストファイルを作成するには**

1. 空のテキストファイルを作成します。

1. インポートする画像ごとに JSON Lines を追加します。各 JSON 行は次のようになります。

   ```
   {"source-ref":"s3://custom-labels-console-us-east-1-nnnnnnnnnn/gt-job/manifest/IMG_1133.png","TestCLConsoleBucket":0,"TestCLConsoleBucket-metadata":{"confidence":0.95,"job-name":"labeling-job/testclconsolebucket","class-name":"Echo Dot","human-annotated":"yes","creation-date":"2020-04-15T20:17:23.433061","type":"groundtruth/image-classification"}}
   ```

1. ファイルを保存します。`.manifest` 拡張機能を使用できますが、必須ではありません。

1. 作成したマニフェストファイルを使用してデータセットを作成します。詳細については、「[SageMaker AI Ground Truth 形式のマニフェストファイルを使用してデータセットを作成するには (コンソール)](md-create-manifest-file.md#create-dataset-procedure-manifest-file)」を参照してください。

 

## イメージレベルの JSON 行
<a name="md-manifest-classification-json"></a>

このセクションでは、1 つのイメージの JSON 行を作成する方法について説明します。次のイメージについて考えます。次のイメージは、*日の出*のようなシーンです。

![\[山々に囲まれた湖に沈む夕日。桟橋と小さなボートが見える。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/customlabels-dg/images/sunrise.png)


上のイメージの*日の出*というシーンの JSON 行は次のようになります。

```
{
    "source-ref": "s3://bucket/images/sunrise.png",
    "testdataset-classification_Sunrise": 1,
    "testdataset-classification_Sunrise-metadata": {
        "confidence": 1,
        "job-name": "labeling-job/testdataset-classification_Sunrise",
        "class-name": "Sunrise",
        "human-annotated": "yes",
        "creation-date": "2020-03-06T17:46:39.176",
        "type": "groundtruth/image-classification"
    }
}
```

以下の情報に注意してください。

### source-ref
<a name="w2aac20c17c25c27c19c11c13"></a>

(必須) 画像の Amazon S3 の場所。形式は `"s3://BUCKET/OBJECT_PATH"` です。インポートされたデータセット内の画像は、同じ Amazon S3 バケットに格納する必要があります。

### *testdataset-classification\$1Sunrise*
<a name="w2aac20c17c25c27c19c11c15"></a>

(必須) ラベル属性。フィールド名を選択します。フィールド値 (前の例では 1) はラベル属性識別子です。Amazon Rekognition Custom Labels では使用されないため、整数値ならどのような値でも構いません。末尾に *-metadata* が付いたフィールド名により特定される該当メタデータが必要です。例えば、`"testdataset-classification_Sunrise-metadata"`。

### *testdataset-classification\$1Sunrise*-metadata
<a name="w2aac20c17c25c27c19c11c17"></a>

(必須) ラベル属性に関するメタデータ。フィールド名は、*-metadata* を付加したラベル属性と同じでなければなりません。

*confidence*  
(必須) 現在 Amazon Rekognition Custom Labels では使用されていませんが、0 から 1 の間の値を指定する必要があります。

*job-name*  
(オプション) 画像を処理するジョブに対して選択した名前。

*class-name*  
(必須) イメージに適用されるシーンまたは概念に対して選択したクラス名。例えば、`"Sunrise"`。

*human-annotated*  
(必須) アノテーションが人によって完成されている場合、`"yes"` を指定します。それ以外の場合は、`"no"` です。

*creation-date*   
(必須) ラベルが作成された協定世界時 (UTC) の日時。

*type*  
(必須) 画像に適用する処理のタイプ。イメージレベルのラベルの場合、値は `"groundtruth/image-classification"` です。

### 複数のイメージレベルのラベルをイメージに追加する
<a name="md-dataset-purpose-classification-multiple-labels"></a>

イメージには複数のラベルを追加できます。例えば、次の JSON では 1 つのイメージに *football* と *ball* の 2 つのラベルを追加します。

```
{
    "source-ref": "S3 bucket location", 
    "sport0":0, # FIRST label
    "sport0-metadata": { 
        "class-name": "football", 
        "confidence": 0.8, 
        "type":"groundtruth/image-classification", 
        "job-name": "identify-sport", 
        "human-annotated": "yes", 
        "creation-date": "2018-10-18T22:18:13.527256" 
    },
    "sport1":1, # SECOND label
    "sport1-metadata": { 
        "class-name": "ball", 
        "confidence": 0.8, 
        "type":"groundtruth/image-classification", 
        "job-name": "identify-sport", 
        "human-annotated": "yes", 
        "creation-date": "2018-10-18T22:18:13.527256" 
    }
}  # end of annotations for 1 image
```

# マニフェストファイル内のオブジェクトのローカリゼーション
<a name="md-create-manifest-file-object-detection"></a>

SageMaker AI Ground Truth [境界ボックスジョブ出力](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box)形式の JSON 行をマニフェストファイルに追加することで、オブジェクトのローカリゼーション情報でラベル付けされたイメージをインポートできます。

ローカリゼーション情報は、イメージ上のオブジェクトの位置を表します。位置は、オブジェクトを囲む境界ボックスで表されます。境界ボックスの構造には、境界ボックスの左上の座標と、境界ボックスの幅と高さが含まれます。境界ボックス形式の JSON 行には、イメージ上の 1 つ以上のオブジェクトの位置と、イメージ上の各オブジェクトのクラスの境界ボックスが含まれます。

マニフェストファイルは 1 行以上の JSON 行で構成され、各行には 1 つのイメージの情報が含まれます。

**オブジェクトローカリゼーションのマニフェストファイルを作成するには**

1. 空のテキストファイルを作成します。

1. インポートする画像ごとに JSON Lines を追加します。各 JSON 行は次のようになります。

   ```
   {"source-ref": "s3://bucket/images/IMG_1186.png", "bounding-box": {"image_size": [{"width": 640, "height": 480, "depth": 3}], "annotations": [{ "class_id": 1,	"top": 251,	"left": 399, "width": 155, "height": 101}, {"class_id": 0, "top": 65, "left": 86, "width": 220,	"height": 334}]}, "bounding-box-metadata": {"objects": [{ "confidence": 1}, {"confidence": 1}],	"class-map": {"0": "Echo",	"1": "Echo Dot"}, "type": "groundtruth/object-detection", "human-annotated": "yes",	"creation-date": "2013-11-18T02:53:27", "job-name": "my job"}}
   ```

1. ファイルを保存します。`.manifest` 拡張機能を使用できますが、必須ではありません。

1. 作成したファイルを使用してデータセットを作成します。詳細については、「[SageMaker AI Ground Truth 形式のマニフェストファイルを使用してデータセットを作成するには (コンソール)](md-create-manifest-file.md#create-dataset-procedure-manifest-file)」を参照してください。



## オブジェクト境界ボックスの JSON 行
<a name="md-manifest-object-localization-json"></a>

このセクションでは、1 つのイメージの JSON 行を作成する方法について説明します。次のイメージは、Amazon Echo デバイスと Amazon Echo Dot デバイスの周囲の境界ボックスを示しています。

![\[木製の表面に置かれた 2 台の Amazon スマートスピーカー。1 台は緑色の境界ボックス、もう 1 台は青色の境界ボックスで囲まれている。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/customlabels-dg/images/echos.png)


以下は、前のイメージの境界ボックスの JSON 行です。

```
{
	"source-ref": "s3://custom-labels-bucket/images/IMG_1186.png",
	"bounding-box": {
		"image_size": [{
			"width": 640,
			"height": 480,
			"depth": 3
		}],
		"annotations": [{
			"class_id": 1,
			"top": 251,
			"left": 399,
			"width": 155,
			"height": 101
		}, {
			"class_id": 0,
			"top": 65,
			"left": 86,
			"width": 220,
			"height": 334
		}]
	},
	"bounding-box-metadata": {
		"objects": [{
			"confidence": 1
		}, {
			"confidence": 1
		}],
		"class-map": {
			"0": "Echo",
			"1": "Echo Dot"
		},
		"type": "groundtruth/object-detection",
		"human-annotated": "yes",
		"creation-date": "2013-11-18T02:53:27",
		"job-name": "my job"
	}
}
```

以下の情報に注意してください。

### source-ref
<a name="cd-manifest-source-ref"></a>

(必須) 画像の Amazon S3 の場所。形式は `"s3://BUCKET/OBJECT_PATH"` です。インポートされたデータセット内の画像は、同じ Amazon S3 バケットに格納する必要があります。

### *bounding-box*
<a name="md-manifest-source-bounding-box"></a>

(必須) ラベル属性。フィールド名を選択します。イメージサイズと、イメージ内で検知された各オブジェクトの境界ボックスが含まれます。末尾に *-metadata* が付いたフィールド名により特定される該当メタデータが必要です。例えば、`"bounding-box-metadata"`。

*image\$1size*  
(必須) イメージのサイズ (ピクセル単位) を含む単一要素の配列。  
+ *height* - (必須) イメージの高さ (ピクセル単位)。
+ *width* - (必須) イメージの奥行き (ピクセル単位)。
+ *depth* - (必須) イメージ内のチャネル数。RGB イメージの最大値は 3 です。Amazon Rekognition Custom Labels では現在使用されていませんが、値が必要です。

*annotations*  
(必須) イメージ内で検知された各オブジェクトの境界ボックス情報の配列。  
+ *class\$1id* - (必須) *class-map* のラベルにマッピングします。前の例では、*class\$1id* が `1` のオブジェクトは、イメージ内の Echo Dot です。
+ *top* - (必須) イメージの上部から境界ボックスの上部までの距離 (ピクセル単位)。
+ *left* - (必須) イメージの左から境界ボックスの左までの距離 (ピクセル単位)。
+ *width* - (必須) 境界ボックスの幅 (ピクセル単位)。
+ *height* - (必須) 境界ボックスの高さ (ピクセル単位)。

### *bounding-box*-metadata
<a name="md-manifest-source-bounding-box-metadata"></a>

(必須) ラベル属性に関するメタデータ。フィールド名は、*-metadata* を付加したラベル属性と同じでなければなりません。イメージ内で検知された各オブジェクトの境界ボックス情報の配列。

*オブジェクト*  
(必須) イメージ内のオブジェクトの配列。インデックスによって *annotations* 配列にマッピングされます。Amazon Rekognition Custom Labels では、信頼性属性は使用されません。

*class-map*  
(必須) イメージ内で検知されたオブジェクトに適用されるクラスのマップ。

*type*  
(必須) 分類ジョブのタイプ。`"groundtruth/object-detection"` はジョブをオブジェクト検知として識別します。

*creation-date*   
(必須) ラベルが作成された協定世界時 (UTC) の日時。

*human-annotated*  
(必須) アノテーションが人によって完成されている場合、`"yes"` を指定します。それ以外の場合は、`"no"` です。

*job-name*  
(オプション) イメージを処理するジョブの名前。

# マニフェストファイルの検証ルール
<a name="md-create-manifest-file-validation-rules"></a>

 マニフェストファイルをインポートすると、Amazon Rekognition Custom Labels は制限、構文、セマンティクスの検証ルールを適用します。SageMaker AI Ground Truth スキーマは構文検証を適用します。詳細については、「[出力](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html)」を参照してください。制限とセマンティクスの検証規則は次のとおりです。

**注記**  
20% の無効ルールは、すべての検証ルールに累積で適用されます。JSON が 15% 無効、イメージが 15% など、何らかの組み合わせでインポートが 20% の制限を超えた場合、インポートは失敗します。
各データセットオブジェクトはマニフェスト内の 1 行です。空白行や無効行もデータセットオブジェクトとしてカウントされます。
オーバーラップは (テストとトレーニングの共通ラベル)/(トレーニングラベル) です。

**Topics**
+ [制限](#md-validation-rules-limits)
+ [セマンティクス](#md-validation-rules-semantics)

## 制限
<a name="md-validation-rules-limits"></a>


| 検証 | 制限 | エラー発生 | 
| --- | --- | --- | 
|  マニフェストファイルのサイズ  |  最大 1 GB  |  エラー  | 
|  マニフェストファイルの最大行数  |  マニフェストの 1 行あたりのデータセットオブジェクトの最大数は 250,000 です。  |  エラー  | 
|  ラベルごとの有効なデータセットオブジェクトの合計の下限   |  >=1  |  エラー  | 
|  ラベルの下限  |  >=2  |  エラー  | 
|  ラベルの上限  |  <= 250  |  エラー  | 
|  イメージごとの最小境界ボックス  |  0  |  なし  | 
|  イメージごとの最大境界ボックス  |  50  |  なし  | 

## セマンティクス
<a name="md-validation-rules-semantics"></a>




| 検証 | 制限 | エラー発生 | 
| --- | --- | --- | 
|  マニフェストが空  |    |  エラー  | 
|  source-ref オブジェクトが見つからない、またはアクセスできない  |  20% 未満のオブジェクト数  |  警告  | 
|  source-ref オブジェクトが見つからない、またはアクセスできない  |  プロジェクト数 > 20%  |  エラー  | 
|  トレーニングデータセットにテストラベルがない   |  ラベルのオーバーラップが 50% 以上  |  エラー  | 
|  データセット内の同じラベルのラベルサンプルとオブジェクトサンプルが混合している。データセットオブジェクト内の同じクラスの分類と検知。  |    |  エラー/警告なし  | 
|  テスト用とトレーニング用のアセットの重複   |  テストデータセットとトレーニングデータセットの間の重複がないこと。  |    | 
|  データセット内のイメージが同じバケットにある   |  オブジェクトが別のバケットにある場合はエラーになる。  |  エラー  | 

# 他のデータセット形式をマニフェストファイルに変換する
<a name="md-converting-to-sm-format"></a>

以下の情報を使用して、さまざまなソースデータセット形式から Amazon SageMaker AI 形式のマニフェストファイルを作成できます。マニフェストファイルを作成したら、それを使用してデータセットを作成します。詳細については、「[マニフェストファイルを使用した画像のインポート](md-create-dataset-ground-truth.md)」を参照してください。

**Topics**
+ [COCO データセットからマニフェストファイル形式への変換](md-transform-coco.md)
+ [マルチラベルの SageMaker AI Ground Truth マニフェストファイルの変換](md-gt-cl-transform.md)
+ [CSV ファイルからのマニフェストファイルの作成](ex-csv-manifest.md)

# COCO データセットからマニフェストファイル形式への変換
<a name="md-transform-coco"></a>

[COCO](http://cocodataset.org/#home) は、大規模なオブジェクト検知、セグメンテーション、キャプションデータセットを指定するための形式です。この Python の[例](md-coco-transform-example.md)では、COCO オブジェクト検知形式のデータセットを Amazon Rekognition Custom Labels [境界ボックス形式のマニフェストファイル](md-create-manifest-file-object-detection.md)に変換する方法を示しています。このセクションには、独自のコードを記述するために使用できる情報も含まれています。

COCO 形式の JSON ファイルは、*データセット全体*の情報を提供する 5 つのセクションで構成されています。詳細については、「[COCO データセット形式](md-coco-overview.md)」を参照してください。
+ `info` - データセットに関する一般情報。
+ `licenses ` - データセット内のイメージのライセンス情報。
+ [`images`](md-coco-overview.md#md-coco-images) - データセット内のイメージのリスト。
+ [`annotations`](md-coco-overview.md#md-coco-annotations) - データセット内のすべてのイメージに含まれる注釈 (境界ボックスを含む) のリスト。
+ [`categories`](md-coco-overview.md#md-coco-categories) - ラベルカテゴリのリスト。

Amazon Rekognition Custom Labels マニフェストファイルを作成するには `images`、`annotations`、および `categories` のリストの情報が必要です。

Amazon Rekognition Custom Labels マニフェストファイルは JSON 行形式で、各行には*イメージ*の 1 つ以上のオブジェクトの境界ボックスとラベル情報が含まれます。詳細については、「[マニフェストファイル内のオブジェクトのローカリゼーション](md-create-manifest-file-object-detection.md)」を参照してください。

## COCO オブジェクトをカスタムラベルの JSON 行にマッピングする
<a name="md-mapping-coco"></a>

COCO 形式のデータセットを変換するには、COCO データセットを Amazon Rekognition Custom Labels マニフェストファイルにマッピングして、オブジェクトのローカリゼーションを行います。詳細については、「[マニフェストファイル内のオブジェクトのローカリゼーション](md-create-manifest-file-object-detection.md)」を参照してください。イメージごとに JSON 行を作成するには、マニフェストファイルに COCO データセット `image`、`annotation`、および `category` オブジェクトフィールド ID をマッピングする必要があります。

次は、COCO マニフェストファイルの例です。詳細については、「[COCO データセット形式](md-coco-overview.md)」を参照してください。

```
{
    "info": {
        "description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
    },
    "licenses": [
        {"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
    ],
    "images": [
        {"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
        {"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
    ],
    "annotations": [
        {"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
        {"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
        {"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
    ],
    "categories": [
        {"supercategory": "speaker","id": 0,"name": "echo"},
        {"supercategory": "speaker","id": 1,"name": "echo dot"}
    ]
}
```

次の図では、データセットの COCO *データセット*のリストが、*イメージ*の Amazon Rekognition Custom Labels JSON 行にどのようにマッピングされるかを示しています。画像の各 JSON 行には、source-ref、job、および job metadata フィールドがあります。一致する色は、1 つのイメージの情報を示しています。マニフェストでは、1 つの画像に複数の注釈とメタデータ/カテゴリが含まれる場合があります。

![\[画像、注釈、カテゴリを含む Coco マニフェストの構造を示す図。\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/customlabels-dg/images/coco-transform.png)


**単一の JSON 行の COCO オブジェクトを取得するには**

1. イメージリスト内の各イメージについて、注釈リストから、注釈フィールド `image_id` の値がイメージ `id` フィールドと一致する注釈を取得します。

1. ステップ 1 で一致した注釈ごとに、`categories` リストを読み込み、`category` フィールド `id` の値が `annotation` オブジェクトの `category_id` フィールドと一致する各 `category` を取得します。

1. 一致した `image`、`annotation`、および `category` オブジェクトを使用して、イメージの JSON 行を作成します。フィールドをマッピングするには、「[COCO オブジェクトフィールドをカスタムラベル JSON 行オブジェクトフィールドにマッピングする](#md-mapping-fields-coco)」を参照してください。

1. `images` リスト内の各 `image` オブジェクトに JSON 行が作成されるまで、ステップ 1～3 を繰り返します。

サンプルコードについては、「[COCO データセットの変換](md-coco-transform-example.md)」を参照してください。

## COCO オブジェクトフィールドをカスタムラベル JSON 行オブジェクトフィールドにマッピングする
<a name="md-mapping-fields-coco"></a>

Amazon Rekognition Custom Labels JSON 行の COCO オブジェクトを特定したら、COCO オブジェクトフィールドをそれぞれの Amazon Rekognition Custom Labels JSON 行オブジェクトフィールドにマッピングする必要があります。次の Amazon Rekognition Custom Labels JSON 行の例では、1 つのイメージ (`id`=`000000245915`) を前述の COCO JSON の例にマッピングしています。以下の情報に注意してください。
+ `source-ref` は Amazon S3 バケット内のイメージの場所です。COCO のイメージが Amazon S3 バケットに保存されていない場合は、それらを Amazon S3 バケットに移動する必要があります。
+ `annotations` リストには、イメージのオブジェクトごとに 1 つの `annotation` オブジェクトが含まれています。`annotation` オブジェクトには、境界ボックス情報 (`top`、`left`、`width`、`height`) とラベル識別子 (`class_id`) が含まれます。
+ ラベル識別子 (`class_id`) はメタデータ内の `class-map` リストにマッピングされます。イメージに使用されているラベルが一覧表示されます。

```
{
	"source-ref": "s3://custom-labels-bucket/images/000000245915.jpg",
	"bounding-box": {
		"image_size": {
			"width": 640,
			"height": 480,
			"depth": 3
		},
		"annotations": [{
			"class_id": 0,
			"top": 251,
			"left": 399,
			"width": 155,
			"height": 101
		}, {
			"class_id": 1,
			"top": 65,
			"left": 86,
			"width": 220,
			"height": 334
		}]
	},
	"bounding-box-metadata": {
		"objects": [{
			"confidence": 1
		}, {
			"confidence": 1
		}],
		"class-map": {
			"0": "Echo",
			"1": "Echo Dot"
		},
		"type": "groundtruth/object-detection",
		"human-annotated": "yes",
		"creation-date": "2018-10-18T22:18:13.527256",
		"job-name": "my job"
	}
}
```

以下の情報を使用して、Amazon Rekognition Custom Labels マニフェストファイルフィールドを COCO データセット JSON フィールドにマッピングします。

### source-ref
<a name="md-source-ref-coco"></a>

イメージの場所の S3 形式の URL。イメージは S3 バケットに保存されている必要があります。詳細については、「[source-ref](md-create-manifest-file-object-detection.md#cd-manifest-source-ref)」を参照してください。`coco_url` COCO フィールドが S3 バケットの場所を指している場合、`coco_url` の値には `source-ref` の値を使用できます。または、`source-ref` を `file_name` (COCO) フィールドにマッピングし、イメージが保存されている場所に必要な S3 パスを変換コードに追加することもできます。

### *bounding-box*
<a name="md-label-attribute-id-coco"></a>

選択したラベルの属性名。詳細については、「[*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box)」を参照してください。

#### image\$1size
<a name="md-image-size-coco"></a>

イメージサイズ (ピクセル単位) [イメージ](md-coco-overview.md#md-coco-images)リストの `image` オブジェクトにマッピングします。
+ `height`-> `image.height`
+ `width`-> `image.width`
+ `depth`-> Amazon Rekognition Custom Labels では使用されませんが、値を指定する必要があります。

#### annotations
<a name="md-annotations-coco"></a>

`annotation` オブジェクトのリスト。イメージのオブジェクトごとに 1 つの `annotation` があります。

#### 注釈
<a name="md-annotation-coco"></a>

イメージのオブジェクトの 1 つのインスタンスの境界ボックス情報が含まれます。
+ `class_id`-> カスタムラベルの `class-map` リストへの数値 ID マッピング。
+ `top` -> `bbox[1]`
+ `left` -> `bbox[0]`
+ `width` -> `bbox[2]`
+ `height` -> `bbox[3]`

### *bounding-box*-metadata
<a name="md-metadata-coco"></a>

ラベル属性のメタデータ。ラベルとラベル ID が含まれています。詳細については、「[*bounding-box*-metadata](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata)」を参照してください。

#### オブジェクト
<a name="cd-metadata-objects-coco"></a>

イメージ内のオブジェクトの配列。インデックスによって `annotations` リストにマッピングされます。

##### オブジェクト
<a name="cd-metadata-object-coco"></a>
+ `confidence`->Amazon Rekognition Custom Labels では使用されませんが、値 (1) が必要です。

#### class-map
<a name="md-metadata-class-map-coco"></a>

イメージ内で検知されたオブジェクトに適用されるラベル (クラス) のマップ。[カテゴリ](md-coco-overview.md#md-coco-categories)リスト内のカテゴリオブジェクトにマッピングします。
+ `id` -> `category.id`
+ `id value` -> `category.name`

#### 型
<a name="md-type-coco"></a>

`groundtruth/object-detection` を指定してください

#### human-annotated
<a name="md-human-annotated-coco"></a>

`yes` または `no` を指定します。詳細については、「[*bounding-box*-metadata](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata)」を参照してください。

#### creation-date -> [image](md-coco-overview.md#md-coco-images).date\$1captured
<a name="md-creation-date-coco"></a>

イメージの作成日時。COCO イメージリストの [image](md-coco-overview.md#md-coco-images).date\$1captured フィールドにマッピングされます。Amazon Rekognition Custom Labels では、`creation-date` の形式が *Y-M-DTH:M:S* であることを想定しています。

#### job-name
<a name="md-job-name-coco"></a>

ユーザーが選択したジョブ名。

# COCO データセット形式
<a name="md-coco-overview"></a>

COCO データセットは、データセット全体の情報を提供する 5 つの情報セクションで構成されています。COCO オブジェクト検知データセットの形式は「[COCO Data Format](http://cocodataset.org/#format-data)」に記載されています。
+ info - データセットに関する一般情報。
+ licenses - データセット内のイメージのライセンス情報。
+ [images](#md-coco-images) - データセット内のイメージのリスト。
+ [annotations](#md-coco-annotations) - データセット内のすべてのイメージに含まれる注釈 (境界ボックスを含む) のリスト。
+ [categories](#md-coco-categories) - ラベルカテゴリのリスト。

カスタムラベルマニフェストを作成するには、COCO マニフェストファイルの `images`、`annotations`、および `categories` リストを使用します。他のセクション (`info`、`licences`) は必須ではありません。次は、COCO マニフェストファイルの例です。

```
{
    "info": {
        "description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
    },
    "licenses": [
        {"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
    ],
    "images": [
        {"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
        {"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
    ],
    "annotations": [
        {"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
        {"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
        {"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
    ],
    "categories": [
        {"supercategory": "speaker","id": 0,"name": "echo"},
        {"supercategory": "speaker","id": 1,"name": "echo dot"}
    ]
}
```

## イメージリスト
<a name="md-coco-images"></a>

COCO データセットが参照するイメージは、イメージ配列に一覧表示されます。各イメージオブジェクトには、イメージファイル名などのイメージに関する情報が含まれています。次のイメージオブジェクトの例では、次の情報と、Amazon Rekognition Custom Labels マニフェストファイルを作成するために必要なフィールドを記録しておきます。
+ `id` - (必須) イメージの一意の識別子。`id` フィールドは、annotations 配列 (境界ボックス情報が格納されている) の `id` フィールドにマッピングされます。
+ `license` - (不要) ライセンス配列にマッピングします。
+ `coco_url` - (オプション) スキーマの場所。
+ `flickr_url` - (不要) Flickr のイメージの場所。
+ `width` - (必須) イメージの幅。
+ `height` - (必須) イメージの高さ。
+ `file_name` - (必須) イメージのファイル名。この例では `file_name` と `id` が一致していますが、これは COCO データセットの要件ではありません。
+ `date_captured` - (必須) イメージがキャプチャされた日時。

```
{
    "id": 245915,
    "license": 4,
    "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg",
    "flickr_url": "http://farm1.staticflickr.com/88/nnnnnnnnnnnnnnnnnnn.jpg",
    "width": 640,
    "height": 480,
    "file_name": "000000245915.jpg",
    "date_captured": "2013-11-18 02:53:27"
}
```

## 注釈 (境界ボックス) リスト
<a name="md-coco-annotations"></a>

全イメージのすべてのオブジェクトの境界ボックス情報は、注釈リストに保存されます。1 つの注釈オブジェクトには、1 つのオブジェクトの境界ボックス情報と、イメージのオブジェクトのラベルが含まれています。イメージのオブジェクトのインスタンスごとに 1 つの注釈オブジェクトがあります。

次の例では、次の情報と、Amazon Rekognition Custom Labels マニフェストファイルを作成するために必要なフィールドを記録しておきます。
+ `id` - (不要) 注釈の識別子。
+ `image_id` - (必須) イメージ配列内のイメージ `id` に対応します。
+ `category_id` - (必須) 境界ボックス内のオブジェクトを識別するラベルの識別子。カテゴリ配列の `id` フィールドにマッピングされます。
+ `iscrowd` - (不要) イメージに多数のオブジェクトが含まれているかどうかを指定します。
+ `segmentation` - (不要) イメージのオブジェクトのセグメンテーション情報。Amazon Rekognition Custom Labels はセグメンテーションをサポートしていません。
+ `area` - (不要) 注釈の領域。
+ `bbox` - (必須) イメージのオブジェクトを囲む境界ボックスの座標 (ピクセル単位) が含まれます。

```
{
    "id": 1409619,
    "category_id": 1,
    "iscrowd": 0,
    "segmentation": [
        [86.0, 238.8,..........382.74, 241.17]
    ],
    "image_id": 245915,
    "area": 3556.2197000000015,
    "bbox": [86, 65, 220, 334]
}
```

## カテゴリリスト
<a name="md-coco-categories"></a>

ラベル情報は、カテゴリ配列に保存されます。次のカテゴリオブジェクトの例では、次の情報と、Amazon Rekognition Custom Labels マニフェストファイルを作成するために必要なフィールドを記録しておきます。
+ `supercategory` - (不要) ラベルの親カテゴリ。
+ `id` - (必須) ラベル識別子。`id` フィールドは `annotation` オブジェクト内の `category_id` フィールドにマッピングされます。次の例では、Echo Dot の識別子は 2 です。
+ `name` - (必須) ラベル名。

```
        {"supercategory": "speaker","id": 2,"name": "echo dot"}
```

# COCO データセットの変換
<a name="md-coco-transform-example"></a>

次の Python の例を使用して、境界ボックス情報を、COCO 形式のデータセットから Amazon Rekognition Custom Labels マニフェストファイルに変換します。このコードは、作成したマニフェストファイルを Amazon S3 バケットにアップロードします。このコードには、イメージのアップロードに使用できる AWS CLI コマンドも用意されています。

**COCO データセットを変換するには (SDK)**

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

   1. `AmazonS3FullAccess` の権限があることを確認します。詳細については、「[SDK アクセス許可の設定](su-sdk-permissions.md)」を参照してください。

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

1. 次の Python コードを使用して COCO データセットを変換します。次の値を設定します。
   + `s3_bucket` - イメージと Amazon Rekognition Custom Labels マニフェストファイルを保存する S3 バケットの名前。
   + `s3_key_path_images` - S3 バケット (`s3_bucket`) 内のイメージを保存する場所へのパス。
   + `s3_key_path_manifest_file` - S3 バケット (`s3_bucket`) 内の Custom Labels マニフェストファイルを保存する場所へのパス。
   + `local_path` - サンプルが入力 COCO データセットを開き、新しいカスタムラベルマニフェストファイルを保存するローカルパス。
   + `local_images_path` - トレーニングに使用するイメージへのローカルパス。
   + `coco_manifest` - 入力 COCO データセットのファイル名。
   + `cl_manifest_file` - このサンプルで作成されたマニフェストファイルの名前。ファイルは `local_path` で指定された場所に保存されます。慣例により、ファイルには拡張子 `.manifest` が付いていますが、必須ではありません。
   + `job_name` - カスタムラベルジョブの名前。

   ```
   import json
   import os
   import random
   import shutil
   import datetime
   import botocore
   import boto3
   import PIL.Image as Image
   import io
   
   #S3 location for images
   s3_bucket = 'bucket'
   s3_key_path_manifest_file = 'path to custom labels manifest file/'
   s3_key_path_images = 'path to images/'
   s3_path='s3://' + s3_bucket  + '/' + s3_key_path_images
   s3 = boto3.resource('s3')
   
   #Local file information
   local_path='path to input COCO dataset and output Custom Labels manifest/'
   local_images_path='path to COCO images/'
   coco_manifest = 'COCO dataset JSON file name'
   coco_json_file = local_path + coco_manifest
   job_name='Custom Labels job name'
   cl_manifest_file = 'custom_labels.manifest'
   
   label_attribute ='bounding-box'
   
   open(local_path + cl_manifest_file, 'w').close()
   
   # class representing a Custom Label JSON line for an image
   class cl_json_line:  
       def __init__(self,job, img):  
   
           #Get image info. Annotations are dealt with seperately
           sizes=[]
           image_size={}
           image_size["width"] = img["width"]
           image_size["depth"] = 3
           image_size["height"] = img["height"]
           sizes.append(image_size)
   
           bounding_box={}
           bounding_box["annotations"] = []
           bounding_box["image_size"] = sizes
   
           self.__dict__["source-ref"] = s3_path + img['file_name']
           self.__dict__[job] = bounding_box
   
           #get metadata
           metadata = {}
           metadata['job-name'] = job_name
           metadata['class-map'] = {}
           metadata['human-annotated']='yes'
           metadata['objects'] = [] 
           date_time_obj = datetime.datetime.strptime(img['date_captured'], '%Y-%m-%d %H:%M:%S')
           metadata['creation-date']= date_time_obj.strftime('%Y-%m-%dT%H:%M:%S') 
           metadata['type']='groundtruth/object-detection'
           
           self.__dict__[job + '-metadata'] = metadata
   
   
   print("Getting image, annotations, and categories from COCO file...")
   
   with open(coco_json_file) as f:
   
       #Get custom label compatible info    
       js = json.load(f)
       images = js['images']
       categories = js['categories']
       annotations = js['annotations']
   
       print('Images: ' + str(len(images)))
       print('annotations: ' + str(len(annotations)))
       print('categories: ' + str(len (categories)))
   
   
   print("Creating CL JSON lines...")
       
   images_dict = {image['id']: cl_json_line(label_attribute, image) for image in images}
   
   print('Parsing annotations...')
   for annotation in annotations:
   
       image=images_dict[annotation['image_id']]
   
       cl_annotation = {}
       cl_class_map={}
   
       # get bounding box information
       cl_bounding_box={}
       cl_bounding_box['left'] = annotation['bbox'][0]
       cl_bounding_box['top'] = annotation['bbox'][1]
    
       cl_bounding_box['width'] = annotation['bbox'][2]
       cl_bounding_box['height'] = annotation['bbox'][3]
       cl_bounding_box['class_id'] = annotation['category_id']
   
       getattr(image, label_attribute)['annotations'].append(cl_bounding_box)
   
   
       for category in categories:
            if annotation['category_id'] == category['id']:
               getattr(image, label_attribute + '-metadata')['class-map'][category['id']]=category['name']
           
       
       cl_object={}
       cl_object['confidence'] = int(1)  #not currently used by Custom Labels
       getattr(image, label_attribute + '-metadata')['objects'].append(cl_object)
   
   print('Done parsing annotations')
   
   # Create manifest file.
   print('Writing Custom Labels manifest...')
   
   for im in images_dict.values():
   
       with open(local_path+cl_manifest_file, 'a+') as outfile:
               json.dump(im.__dict__,outfile)
               outfile.write('\n')
               outfile.close()
   
   # Upload manifest file to S3 bucket.
   print ('Uploading Custom Labels manifest file to S3 bucket')
   print('Uploading'  + local_path + cl_manifest_file + ' to ' + s3_key_path_manifest_file)
   print(s3_bucket)
   s3 = boto3.resource('s3')
   s3.Bucket(s3_bucket).upload_file(local_path + cl_manifest_file, s3_key_path_manifest_file + cl_manifest_file)
   
   # Print S3 URL to manifest file,
   print ('S3 URL Path to manifest file. ')
   print('\033[1m s3://' + s3_bucket + '/' + s3_key_path_manifest_file + cl_manifest_file + '\033[0m') 
   
   # Display aws s3 sync command.
   print ('\nAWS CLI s3 sync command to upload your images to S3 bucket. ')
   print ('\033[1m aws s3 sync ' + local_images_path + ' ' + s3_path + '\033[0m')
   ```

1. コードを実行します。

1. プログラムの出力で、`s3 sync` コマンドを記録しておきます。それは次の手順で必要となります。

1. コマンドラインプロンプトで、`s3 sync` コマンドを実行します。イメージが S3 バケットにアップロードされます。アップロード中にコマンドが失敗した場合は、ローカルイメージ S3 バケットと同期されるまでコマンドを再度実行してください。

1. プログラムの出力で、マニフェストファイルへの S3 URL パスを記録しておきます。それは次の手順で必要となります。

1. 「[SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console)」の手順に従って、アップロードしたマニフェストファイルを使用してデータセットを作成します。ステップ 8 では、**[マニフェストファイルの場所]** に、前のステップで記録しておいた Amazon S3 URL を入力します。 AWS SDK を使用している場合、[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) を実行してください。

# マルチラベルの SageMaker AI Ground Truth マニフェストファイルの変換
<a name="md-gt-cl-transform"></a>

このトピックでは、マルチラベルの Amazon SageMaker AI Ground Truth マニフェストファイルを Amazon Rekognition Custom Labels 形式のマニフェストファイルに変換する方法について説明します。

マルチラベルジョブ用の SageMaker AI Ground Truth マニフェストファイルの形式は、Amazon Rekognition Custom Labels 形式のマニフェストファイルとは異なります。マルチラベル分類は、イメージを複数のクラスに分類しても同時に複数のクラスに属する場合もあります。この場合、イメージには *football* と *ball* などの複数のラベル (マルチラベル) が付けられる可能性があります。

マルチラベルの SageMaker AI Ground Truth ジョブの詳細については、[「イメージ分類 (マルチラベル)](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html)」を参照してください。マルチラベル形式の Amazon Rekognition Custom Labels マニフェストファイルの詳細については、「[複数のイメージレベルのラベルをイメージに追加する](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels)」を参照してください。

## SageMaker AI Ground Truth ジョブのマニフェストファイルの取得
<a name="md-get-gt-manifest"></a>

次の手順は、Amazon SageMaker AI Ground Truth ジョブの出力マニフェストファイル (`output.manifest`) を取得する方法を示しています。次の手順の入力として `output.manifest` を使用します。

**SageMaker AI Ground Truth ジョブマニフェストファイルをダウンロードするには**

1. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) を開きます。

1. ナビゲーションペインで **[Ground Truth]** を選択し、次に **[ラベリングジョブ]** を選択します。

1. 使用するマニフェストファイルを含むラベリングジョブを選択します。

1. 詳細ページで、**[出力データセットの場所]** の下のリンクを選択します。そのデータセットの場所で Amazon S3 コンソールが開きます。

1. [`Manifests`]、[`output`]、[`output.manifest`] の順に選択します。

1. オブジェクトをダウンロードするには、**[オブジェクトアクション]**、**[ダウンロード]** の順に選択します。

## マルチラベルの SageMaker AI マニフェストファイルの変換
<a name="md-transform-ml-gt"></a>

次の手順では、既存のマルチラベル形式の SageMaker AI GroundTruth マニフェストファイルから、マルチラベル形式の Amazon Rekognition Custom Labels マニフェストファイルを作成します。

**注記**  
コードを実行するには、Python バージョン 3 以降が必要です。<a name="md-procedure-multi-label-transform"></a>

**マルチラベルの SageMaker AI マニフェストファイルを変換するには**

1. 次の Python コードを実行します。[SageMaker AI Ground Truth ジョブのマニフェストファイルの取得](#md-get-gt-manifest) で作成したマニフェストファイルの名前をコマンドライン引数として指定します。

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier:  Apache-2.0
   """
   Purpose
   Shows how to create and Amazon Rekognition Custom Labels format
   manifest file from an Amazon SageMaker Ground Truth Image
   Classification (Multi-label) format manifest file.
   """
   import json
   import logging
   import argparse
   import os.path
   
   logger = logging.getLogger(__name__)
   
   def create_manifest_file(ground_truth_manifest_file):
       """
       Creates an Amazon Rekognition Custom Labels format manifest file from
       an Amazon SageMaker Ground Truth Image Classification (Multi-label) format
       manifest file.
       :param: ground_truth_manifest_file: The name of the Ground Truth manifest file,
       including the relative path.
       :return: The name of the new Custom Labels manifest file.
       """
   
       logger.info('Creating manifest file from %s', ground_truth_manifest_file)
       new_manifest_file = f'custom_labels_{os.path.basename(ground_truth_manifest_file)}'
   
       # Read the SageMaker Ground Truth manifest file into memory.
       with open(ground_truth_manifest_file) as gt_file:
           lines = gt_file.readlines()
   
       #Iterate through the lines one at a time to generate the
       #new lines for the Custom Labels manifest file.
       with open(new_manifest_file, 'w') as the_new_file:
           for line in lines:
               #job_name - The of the Amazon Sagemaker Ground Truth job.
               job_name = ''
               # Load in the old json item from the Ground Truth manifest file
               old_json = json.loads(line)
   
               # Get the job name
               keys = old_json.keys()
               for key in keys:
                   if 'source-ref' not in key and '-metadata' not in key:
                       job_name = key
   
               new_json = {}
               # Set the location of the image
               new_json['source-ref'] = old_json['source-ref']
   
               # Temporarily store the list of labels
               labels = old_json[job_name]
   
               # Iterate through the labels and reformat to Custom Labels format
               for index, label in enumerate(labels):
                   new_json[f'{job_name}{index}'] = index
                   metadata = {}
                   metadata['class-name'] = old_json[f'{job_name}-metadata']['class-map'][str(label)]
                   metadata['confidence'] = old_json[f'{job_name}-metadata']['confidence-map'][str(label)]
                   metadata['type'] = 'groundtruth/image-classification'
                   metadata['job-name'] = old_json[f'{job_name}-metadata']['job-name']
                   metadata['human-annotated'] = old_json[f'{job_name}-metadata']['human-annotated']
                   metadata['creation-date'] = old_json[f'{job_name}-metadata']['creation-date']
                   # Add the metadata to new json line
                   new_json[f'{job_name}{index}-metadata'] = metadata
               # Write the current line to the json file
               the_new_file.write(json.dumps(new_json))
               the_new_file.write('\n')
   
       logger.info('Created %s', new_manifest_file)
       return  new_manifest_file
   
   def add_arguments(parser):
       """
       Adds command line arguments to the parser.
       :param parser: The command line parser.
       """
   
       parser.add_argument(
           "manifest_file", help="The Amazon SageMaker Ground Truth manifest file"
           "that you want to use."
       )
   
   
   def main():
       logging.basicConfig(level=logging.INFO,
                           format="%(levelname)s: %(message)s")
       try:
           # get command line arguments
           parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
           add_arguments(parser)
           args = parser.parse_args()
           # Create the manifest file
           manifest_file = create_manifest_file(args.manifest_file)
           print(f'Manifest file created: {manifest_file}')
       except FileNotFoundError as err:
           logger.exception('File not found: %s', err)
           print(f'File not found: {err}. Check your manifest file.')
   
   if __name__ == "__main__":
       main()
   ```

1. スクリプトに表示される新しいマニフェストファイルの名前を記録しておきます。これは次のステップで使います。

1. マニフェストファイルを保存するために使用する Amazon S3 バケットに[マニフェストファイルをアップロード](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)します。
**注記**  
Amazon Rekognition Custom Labels が、マニフェストファイルの JSON 行の `source-ref` フィールドで参照されている Amazon S3 バケットにアクセスできることを確認してください。詳細については、「[外部の Amazon S3 バケットへのアクセス](su-console-policy.md#su-external-buckets)」を参照してください。Ground Truth ジョブが Amazon Rekognition Custom Labels コンソールバケットにイメージを保存する場合、アクセス許可を追加する必要はありません。

1. 「[SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console)」の手順に従って、アップロードしたマニフェストファイルを使用してデータセットを作成します。ステップ 8 では、**[マニフェストファイルの場所]** に、マニフェストファイルの場所として Amazon S3 URL を入力します。 AWS SDK を使用している場合、[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) を実行してください。

# CSV ファイルからのマニフェストファイルの作成
<a name="ex-csv-manifest"></a>

この Python スクリプト例では、カンマ区切り値 (CSV) ファイルを使用してイメージにラベルを付けることにより、マニフェストファイルの作成を簡素化しています。ユーザーによって CSV ファイルを作成します。マニフェストファイルは[マルチラベルイメージ分類](getting-started.md#gs-multi-label-image-classification-example)または [マルチラベルイメージ分類](getting-started.md#gs-multi-label-image-classification-example) に適しています。詳細については、「[オブジェクト、シーン、概念を検出する](understanding-custom-labels.md#tm-classification)」を参照してください。

**注記**  
このスクリプトでは、[オブジェクトの位置](understanding-custom-labels.md#tm-object-localization)や[ブランドの位置](understanding-custom-labels.md#tm-brand-detection-localization)の検索に適したマニフェストファイルは作成されません。

マニフェストファイルには、モデルのトレーニングに使用されるイメージが記述されています。例えば、イメージの位置やイメージに割り当てられたラベルなどです。マニフェストファイルは、1 行以上の JSON 行で構成されます。各 JSON Lines では 1 つの画像について記述されます。詳細については、「[マニフェストファイルでの画像レベルラベルのインポート](md-create-manifest-file-classification.md)」を参照してください。

CSV ファイルは、テキストファイル内の複数行にわたる表形式のデータを表します。行内のフィールドはカンマで区切られます。詳細については、「[カンマ区切り値](https://en.wikipedia.org/wiki/Comma-separated_values)」を参照してください。このスクリプトでは、CSV ファイルの各行が 1 つのイメージを表し、マニフェストファイルの JSON 行にマッピングされます。[マルチラベルイメージ分類](getting-started.md#gs-multi-label-image-classification-example)をサポートするマニフェストファイル用の CSV ファイルを作成するには、各行に 1 つ以上のイメージレベルのラベルを追加します。[イメージ分類](getting-started.md#gs-image-classification-example) に適したマニフェストファイルを作成するには、各行に 1 つのイメージレベルのラベルを追加します。

例えば、次の CSV ファイルには [マルチラベルイメージ分類](getting-started.md#gs-multi-label-image-classification-example) (花) *入門*プロジェクトのイメージが記述されています。

```
camellia1.jpg,camellia,with_leaves
camellia2.jpg,camellia,with_leaves
camellia3.jpg,camellia,without_leaves
helleborus1.jpg,helleborus,without_leaves,not_fully_grown
helleborus2.jpg,helleborus,with_leaves,fully_grown
helleborus3.jpg,helleborus,with_leaves,fully_grown
jonquil1.jpg,jonquil,with_leaves
jonquil2.jpg,jonquil,with_leaves
jonquil3.jpg,jonquil,with_leaves
jonquil4.jpg,jonquil,without_leaves
mauve_honey_myrtle1.jpg,mauve_honey_myrtle,without_leaves
mauve_honey_myrtle2.jpg,mauve_honey_myrtle,with_leaves
mauve_honey_myrtle3.jpg,mauve_honey_myrtle,with_leaves
mediterranean_spurge1.jpg,mediterranean_spurge,with_leaves
mediterranean_spurge2.jpg,mediterranean_spurge,without_leaves
```

このスクリプトは、各行に JSON 行を生成します。例えば、以下は最初の行の JSON 行 (`camellia1.jpg,camellia,with_leaves`) です。

```
{"source-ref": "s3://bucket/flowers/train/camellia1.jpg","camellia": 1,"camellia-metadata":{"confidence": 1,"job-name": "labeling-job/camellia","class-name": "camellia","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"},"with_leaves": 1,"with_leaves-metadata":{"confidence": 1,"job-name": "labeling-job/with_leaves","class-name": "with_leaves","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"}}
```

CSV の例では、イメージへの Amazon S3 パスは存在しません。CSV ファイルにイメージの Amazon S3 パスが含まれていない場合は、`--s3_path` コマンドライン引数を使用してイメージへの Amazon S3 パスを指定します。

このスクリプトは、各イメージの最初のエントリを重複排除されたイメージ CSV ファイルに記録します。重複排除されたイメージ CSV ファイルには、入力 CSV ファイルで見つかった各イメージのインスタンスが含まれています。入力 CSV ファイル内でイメージがさらに見つかると、重複イメージ CSV ファイルに記録されます。スクリプトによって重複イメージが検知された場合は、重複イメージ CSV ファイルを確認し、必要に応じて重複排除されたイメージ CSV ファイルを更新します。重複排除されたファイルを使用してスクリプトを再度実行します。入力 CSV ファイルに重複が見つからなかった場合、スクリプトは重複排除されたイメージ CSV ファイルと重複イメージ CSV ファイルが空として削除します。

 この手順では、CSV ファイルを作成し、Python スクリプトを実行してマニフェストファイルを作成します。

**CSV ファイルからマニフェストファイルを作成するには**

1. 各行に以下のフィールドを含む CSV ファイルを作成します (1 画像ごとに 1 行)。CSV ファイルにはヘッダー行を追加しないでください。    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/rekognition/latest/customlabels-dg/ex-csv-manifest.html)

   例えば、`camellia1.jpg,camellia,with_leaves`、`s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves` などです。

1. CSV ファイルを保存します。

1. 以下の Python スクリプトを実行します。以下の情報を提供します:
   + `csv_file` - ステップ 1 で作成した CSV ファイル。
   + `manifest_file` - 作成するマニフェストファイルの名前。
   + (オプション) `--s3_path s3://path_to_folder/` - イメージファイル名に追加する Amazon S3 パス (フィールド 1)。この段階でフィールド 1 のイメージに S3 パスが含まれていない場合は、`--s3_path` を使用します。

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier:  Apache-2.0
   
   from datetime import datetime, timezone
   import argparse
   import logging
   import csv
   import os
   import json
   
   """
   Purpose
   Amazon Rekognition Custom Labels model example used in the service documentation.
   Shows how to create an image-level (classification) manifest file from a CSV file.
   You can specify multiple image level labels per image.
   CSV file format is
   image,label,label,..
   If necessary, use the bucket argument to specify the S3 bucket folder for the images.
   https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-gt-cl-transform.html
   """
   
   logger = logging.getLogger(__name__)
   
   
   def check_duplicates(csv_file, deduplicated_file, duplicates_file):
       """
       Checks for duplicate images in a CSV file. If duplicate images
       are found, deduplicated_file is the deduplicated CSV file - only the first
       occurence of a duplicate is recorded. Other duplicates are recorded in duplicates_file.
       :param csv_file: The source CSV file.
       :param deduplicated_file: The deduplicated CSV file to create. If no duplicates are found
       this file is removed.
       :param duplicates_file: The duplicate images CSV file to create. If no duplicates are found
       this file is removed.
       :return: True if duplicates are found, otherwise false.
       """
   
       logger.info("Deduplicating %s", csv_file)
   
       duplicates_found = False
   
       # Find duplicates.
       with open(csv_file, 'r', newline='', encoding="UTF-8") as f,\
               open(deduplicated_file, 'w', encoding="UTF-8") as dedup,\
               open(duplicates_file, 'w', encoding="UTF-8") as duplicates:
   
           reader = csv.reader(f, delimiter=',')
           dedup_writer = csv.writer(dedup)
           duplicates_writer = csv.writer(duplicates)
   
           entries = set()
           for row in reader:
               # Skip empty lines.
               if not ''.join(row).strip():
                   continue
   
               key = row[0]
               if key not in entries:
                   dedup_writer.writerow(row)
                   entries.add(key)
               else:
                   duplicates_writer.writerow(row)
                   duplicates_found = True
   
       if duplicates_found:
           logger.info("Duplicates found check %s", duplicates_file)
   
       else:
           os.remove(duplicates_file)
           os.remove(deduplicated_file)
   
       return duplicates_found
   
   
   def create_manifest_file(csv_file, manifest_file, s3_path):
       """
       Reads a CSV file and creates a Custom Labels classification manifest file.
       :param csv_file: The source CSV file.
       :param manifest_file: The name of the manifest file to create.
       :param s3_path: The S3 path to the folder that contains the images.
       """
       logger.info("Processing CSV file %s", csv_file)
   
       image_count = 0
       label_count = 0
   
       with open(csv_file, newline='', encoding="UTF-8") as csvfile,\
               open(manifest_file, "w", encoding="UTF-8") as output_file:
   
           image_classifications = csv.reader(
               csvfile, delimiter=',', quotechar='|')
   
           # Process each row (image) in CSV file.
           for row in image_classifications:
               source_ref = str(s3_path)+row[0]
   
               image_count += 1
   
               # Create JSON for image source ref.
               json_line = {}
               json_line['source-ref'] = source_ref
   
               # Process each image level label.
               for index in range(1, len(row)):
                   image_level_label = row[index]
   
                   # Skip empty columns.
                   if image_level_label == '':
                       continue
                   label_count += 1
   
                  # Create the JSON line metadata.
                   json_line[image_level_label] = 1
                   metadata = {}
                   metadata['confidence'] = 1
                   metadata['job-name'] = 'labeling-job/' + image_level_label
                   metadata['class-name'] = image_level_label
                   metadata['human-annotated'] = "yes"
                   metadata['creation-date'] = \
                       datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')
                   metadata['type'] = "groundtruth/image-classification"
   
                   json_line[f'{image_level_label}-metadata'] = metadata
   
                   # Write the image JSON Line.
               output_file.write(json.dumps(json_line))
               output_file.write('\n')
   
       output_file.close()
       logger.info("Finished creating manifest file %s\nImages: %s\nLabels: %s",
                   manifest_file, image_count, label_count)
   
       return image_count, label_count
   
   
   def add_arguments(parser):
       """
       Adds command line arguments to the parser.
       :param parser: The command line parser.
       """
   
       parser.add_argument(
           "csv_file", help="The CSV file that you want to process."
       )
   
       parser.add_argument(
           "--s3_path", help="The S3 bucket and folder path for the images."
           " If not supplied, column 1 is assumed to include the S3 path.", required=False
       )
   
   
   def main():
   
       logging.basicConfig(level=logging.INFO,
                           format="%(levelname)s: %(message)s")
   
       try:
   
           # Get command line arguments
           parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
           add_arguments(parser)
           args = parser.parse_args()
   
           s3_path = args.s3_path
           if s3_path is None:
               s3_path = ''
   
           # Create file names.
           csv_file = args.csv_file
           file_name = os.path.splitext(csv_file)[0]
           manifest_file = f'{file_name}.manifest'
           duplicates_file = f'{file_name}-duplicates.csv'
           deduplicated_file = f'{file_name}-deduplicated.csv'
   
           # Create manifest file, if there are no duplicate images.
           if check_duplicates(csv_file, deduplicated_file, duplicates_file):
               print(f"Duplicates found. Use {duplicates_file} to view duplicates "
                     f"and then update {deduplicated_file}. ")
               print(f"{deduplicated_file} contains the first occurence of a duplicate. "
                     "Update as necessary with the correct label information.")
               print(f"Re-run the script with {deduplicated_file}")
           else:
               print("No duplicates found. Creating manifest file.")
   
               image_count, label_count = create_manifest_file(csv_file,
                                                               manifest_file,
                                                               s3_path)
   
               print(f"Finished creating manifest file: {manifest_file} \n"
                     f"Images: {image_count}\nLabels: {label_count}")
   
       except FileNotFoundError as err:
           logger.exception("File not found: %s", err)
           print(f"File not found: {err}. Check your input CSV file.")
   
   
   if __name__ == "__main__":
       main()
   ```

1. テストデータセットを使用する場合は、ステップ 1～3 を繰り返してテストデータセットのマニフェストファイルを作成します。

1. 必要に応じて、CSV ファイルの列 1 で指定した (`--s3_path`またはコマンドラインで指定した) Amazon S3 バケットパスにイメージをコピーします。次の AWS S3 コマンドを使用できます。

   ```
   aws s3 cp --recursive your-local-folder s3://your-target-S3-location
   ```

1. マニフェストファイルを保存するために使用する Amazon S3 バケットに[マニフェストファイルをアップロード](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)します。
**注記**  
Amazon Rekognition Custom Labels が、マニフェストファイルの JSON 行の `source-ref` フィールドで参照されている Amazon S3 バケットにアクセスできることを確認してください。詳細については、「[外部の Amazon S3 バケットへのアクセス](su-console-policy.md#su-external-buckets)」を参照してください。Ground Truth ジョブが Amazon Rekognition Custom Labels コンソールバケットにイメージを保存する場合、アクセス許可を追加する必要はありません。

1. 「[SageMaker AI Ground Truth マニフェストファイルを使用したデータセットの作成 (コンソール)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console)」の手順に従って、アップロードしたマニフェストファイルを使用してデータセットを作成します。ステップ 8 では、**[マニフェストファイルの場所]** に、マニフェストファイルの場所として Amazon S3 URL を入力します。 AWS SDK を使用している場合、[SageMaker AI Ground Truth マニフェストファイル (SDK) を使用したデータセットの作成](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) を実行してください。

# 既存のデータセットからのコンテンツのコピー
<a name="md-create-dataset-existing-dataset"></a>

以前にデータセットを作成した場合は、その内容を新しいデータセットにコピーできます。 AWS SDK を使用して既存のデータセットからデータセットを作成するには、「」を参照してください[既存のデータセットを使用したデータセットの作成 (SDK)](md-create-dataset-existing-dataset-sdk.md)。

**既存の Amazon Rekognition Custom Labels データセットを使用してデータセットを作成するには (コンソール)**

1. Amazon Rekognition コンソールを [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) で開きます。

1. **[カスタムラベルを使用]** を選択します。

1. **[開始方法]** を選択します。

1. 左側のナビゲーションペインで、**[プロジェクト]** を選択します。

1. 「**プロジェクト**」ページで、データセットを追加したいプロジェクトを選択します。プロジェクトの詳細ページが表示されます。

1. **[データセットを作成]** を選択します。「**データセットを作成**」ページが表示されます。

1. **[設定の開始]** で、**[1 つのデータセットで開始]** または **[トレーニングデータセットで開始]** を選択します。より高品質のモデルを作成するには、トレーニングデータセットとテストデータセットを別々に始めることを推奨します。

------
#### [ Single dataset ]

   1. **[トレーニングデータセットの詳細]** セクションで、**[既存の Amazon Rekognition Custom Labels データセットをコピー]** を選択します。

   1. **[トレーニングデータセットの詳細]** セクションの**[データセット]** 編集ボックスで、コピーするデータセットの名前を入力または選択します。

   1. **[データセットを作成]** を選択します。プロジェクトのデータセットページが開きます。

------
#### [ Separate training and test datasets ]

   1. **[トレーニングデータセットの詳細]** セクションで、**[既存の Amazon Rekognition Custom Labels データセットをコピー]** を選択します。

   1. **[トレーニングデータセットの詳細]** セクションの**[データセット]** 編集ボックスで、コピーするデータセットの名前を入力または選択します。

   1. **[テストデータセットの詳細]** セクションで、**[既存の Amazon Rekognition Custom Labels データセットをコピー]** を選択します。

   1. **[テストデータセットの詳細]** セクションの**[データセット]** 編集ボックスで、コピーするデータセットの名前を入力または選択します。
**注記**  
トレーニングデータセットとテストデータセットは、異なる画像ソースを持つことができます。

   1. **[データセットを作成]** を選択します。プロジェクトのデータセットページが開きます。

------

1. ラベルの追加または変更の必要がある場合は、[イメージにラベルを付ける](md-labeling-images.md) を実行してください。

1. 「[モデルのトレーニング (コンソール)](training-model.md#tm-console)」の手順に従って、モデルをトレーニングします。