本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 创建 Amazon Rekognition Custom Labels 模型
模型是训练来查找符合您业务需求的独特概念、场景和物体的软件。您可以使用 Amazon Rekognition 自定义标签控制台或软件开发工具包创建模型。 AWS 创建 Amazon Rekognition Custom Labels 模型之前，建议您先阅读[了解 Amazon Rekognition Custom Labels](understanding-custom-labels.md)。
本节介绍有关创建项目、为不同模型类型创建训练和测试数据集以及训练模型的控制台和 SDK 信息。后面的章节将介绍如何改进和使用模型。有关介绍如何通过控制台创建和使用特定类型模型的教程，请参阅[图像分类](tutorial-classification.md)。
**Topics**
+ [创建项目](mp-create-project.md)
+ [创建训练和测试数据集](creating-datasets.md)
+ [训练 Amazon Rekognition Custom Labels 模型](training-model.md)
+ [调试失败的模型训练](tm-debugging.md)
# 创建项目
项目用于管理模型的模型版本、训练数据集和测试数据集。可以使用 Amazon Rekognition Custom Labels 控制台或 API 创建项目。有关其他项目任务（例如删除项目），请参阅[管理 Amazon Rekognition Custom Labels 项目](managing-project.md)。
您可以使用标签对 Amazon Rekognition Custom Labels 资源（包括您的项目）进行分类和管理。
该[CreateProject](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProject)操作允许您在创建新项目时选择性地指定标签，将标签作为键值对提供，可用于对资源进行分类和管理。
## 创建 Amazon Rekognition Custom Labels 项目（控制台）
可以使用 Amazon Rekognition Custom Labels 控制台创建项目。首次在新 AWS 区域使用控制台时，Amazon Rekognition 自定义标签会要求在您的账户中创建一个 Amazon S3 存储桶（控制台存储桶）。 AWS 该存储桶用于存储您的项目文件。必须创建控制台存储桶，才能使用 Amazon Rekognition Custom Labels 控制台。
可以使用 Amazon Rekognition Custom Labels 控制台创建项目。
**创建项目（控制台）**
1. 登录 AWS 管理控制台 并打开亚马逊 Rekognition 控制台，网址为。[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. 在左侧窗格中，选择**使用自定义标签**。随后将显示 Amazon Rekognition Custom Labels 登录页面。
1. 在 Amazon Rekognition Custom Labels 登录页面上，选择**开始**。
1. 在左侧窗格中，选择**项目**。
1. 选择**创建项目**。
1. 在**项目名称**中输入项目名称。
1. 选择**创建项目**，创建您的项目。
1. 按照[创建训练和测试数据集](creating-datasets.md)中的步骤为项目创建训练和测试数据集。
## 创建 Amazon Rekognition Custom Labels 项目 (SDK)
您可以通过调用来创建 Amazon Rekognition 自定义标签项目。[CreateProject](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProject)响应是标识项目的 Amazon 资源名称 (ARN)。创建项目后，可以创建用于训练和测试模型的数据集。有关更多信息，请参阅 [使用图像创建训练和测试数据集](md-create-dataset.md)。
**创建项目 (SDK)**
1. 如果您尚未这样做，请安装并配置 AWS CLI 和 AWS SDKs。有关更多信息，请参阅 [步骤 4：设置 AWS CLI 和 AWS SDKs](su-awscli-sdk.md)。
1. 使用以下代码创建项目。
------
#### [ AWS CLI ]
以下示例会创建一个项目并显示其 ARN。
将 `project-name` 的值更改为要创建的项目的名称。
```
aws rekognition create-project --project-name my_project \
--profile custom-labels-access --"CUSTOM_LABELS" --tags'{"key1":"value1","key2":"value2"}'
```
------
#### [ Python ]
以下示例会创建一个项目并显示其 ARN。提供以下命令行参数：
+ `project_name`：要创建的项目的名称。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_project(rek_client, project_name):
"""
Creates an Amazon Rekognition Custom Labels project
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_name: A name for the new prooject.
"""
try:
#Create the project.
logger.info("Creating project: %s",project_name)
response=rek_client.create_project(ProjectName=project_name)
logger.info("project ARN: %s",response['ProjectArn'])
return response['ProjectArn']
except ClientError as err:
logger.exception("Couldn't create project - %s: %s", project_name, 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_name", help="A name for the new project."
)
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 project: {args.project_name}")
# Create the project.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
project_arn=create_project(rekognition_client,
args.project_name)
print(f"Finished creating project: {args.project_name}")
print(f"ARN: {project_arn}")
except ClientError as err:
logger.exception("Problem creating project: %s", err)
print(f"Problem creating project: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
以下示例会创建一个项目并显示其 ARN。
提供以下命令行参数：
+ `project_name`：要创建的项目的名称。
```
/*
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.CreateProjectRequest;
import software.amazon.awssdk.services.rekognition.model.CreateProjectResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateProject {
public static final Logger logger = Logger.getLogger(CreateProject.class.getName());
public static String createMyProject(RekognitionClient rekClient, String projectName) {
try {
logger.log(Level.INFO, "Creating project: {0}", projectName);
CreateProjectRequest createProjectRequest = CreateProjectRequest.builder().projectName(projectName).build();
CreateProjectResponse response = rekClient.createProject(createProjectRequest);
logger.log(Level.INFO, "Project ARN: {0} ", response.projectArn());
return response.projectArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not create project: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_name - A name for the new project\n\n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String projectName = args[0];
String projectArn = null;
;
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Create the project
projectArn = createMyProject(rekClient, projectName);
System.out.println(String.format("Created project: %s %nProject ARN: %s", projectName, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
1. 记下响应中显示的项目 ARN 的名称。您将需要它来创建模型。
1. 按照[创建训练和测试数据集 (SDK)](md-create-dataset.md#cd-create-dataset-sdk)中的步骤为项目创建训练和测试数据集。
## CreateProject 操作请求
以下是 CreateProject 操作请求的格式：
```
{
"AutoUpdate": "string",
"Feature": "string",
"ProjectName": "string",
"Tags": {
"string": "string"
}
}
```
# 创建训练和测试数据集
数据集是由图像和描述这些图像的标签组成的集合。项目需要一个训练数据集和一个测试数据集。Amazon Rekognition Custom Labels 使用训练数据集来训练模型。训练结束后，Amazon Rekognition Custom Labels 会使用测试数据集来验证训练后的模型预测正确标签的效果。
您可以使用 Amazon Rekognition 自定义标签控制台或软件开发工具包创建数据集。 AWS 在创建数据集之前，建议先阅读[了解 Amazon Rekognition Custom Labels](understanding-custom-labels.md)。有关其他数据集任务，请参阅[管理数据集](managing-dataset.md)。
为项目创建训练和测试数据集的步骤如下：
**为项目创建训练和测试数据集**
1. 确定需要如何标注训练和测试数据集。有关更多信息，请参阅 [确定数据集用途](md-dataset-purpose.md)。
1. 为训练和测试数据集收集图像。有关更多信息，请参阅 [准备图像](md-prepare-images.md)。
1. 创建训练和测试数据集。有关更多信息，请参阅 [使用图像创建训练和测试数据集](md-create-dataset.md)。如果您使用的是 AWS SDK，请参阅[创建训练和测试数据集 (SDK)](md-create-dataset.md#cd-create-dataset-sdk)。
1. 如有必要，可以向数据集图像添加图像级标签或边界框。有关更多信息，请参阅 [标注图像](md-labeling-images.md)。
创建数据集后，即可[训练](training-model.md)模型。
**Topics**
+ [确定数据集用途](md-dataset-purpose.md)
+ [准备图像](md-prepare-images.md)
+ [使用图像创建训练和测试数据集](md-create-dataset.md)
+ [标注图像](md-labeling-images.md)
+ [调试数据集](debugging-datasets.md)
# 确定数据集用途
如何标注项目中的训练和测试数据集决定了所创建的模型的类型。使用 Amazon Rekognition Custom Labels，可以创建执行以下操作的模型。
+ [查找物体、场景和概念](#md-dataset-purpose-classification)
+ [查找物体位置](#md-dataset-purpose-localization)
+ [查找品牌位置](#md-dataset-purpose-brands)
## 查找物体、场景和概念
该模型可对与整个图像相关的物体、场景和概念进行分类。
您可以创建两种类型的分类模型：*图像分类*和*多标签分类*。这两种类型的分类模型都会从用于训练的整套标签中查找一个或多个匹配的标签。训练和测试数据集都需要至少两个标签。
### 图像分类
该模型可将图像归类为属于一组预定义的标签。例如，您可能需要一个模型来确定图像中是否包含生活空间。下图可能具有 *living\$1space* 图像级标签。
![\[舒适惬意的客厅，有壁炉，还有可俯瞰后院露台的大窗户。中性色调，木质装饰。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/living_space1.jpeg)
对于这种类型的模型，请为每个训练和测试数据集图像添加一个图像级标签。如需查看示例项目，请参阅[图像分类](getting-started.md#gs-image-classification-example)。
### 多标签分类
该模型可将图像分为多个类别，例如花的类型以及是否有叶子。例如，下图可能具有 *mediterranean\$1spurge* 和 *no\$1leaves* 图像级标签。
![\[一团带有紧密排列小花的绿色荚莲花的特写镜头。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/mediterranean_spurge3.jpg)
对于这种类型的模型，请将每个类别的图像级标签分配给训练和测试数据集图像。如需查看示例项目，请参阅[多标签图像分类](getting-started.md#gs-multi-label-image-classification-example)。
### 分配图像级标签
如果图像存储在 Amazon S3 存储桶中，则可以使用[文件夹名称](md-create-dataset-s3.md)自动添加图像级标签。有关更多信息，请参阅 [从 Amazon S3 存储桶导入图像](md-create-dataset-s3.md)。您也可以在创建数据集后向图像添加图像级标签。有关更多信息，请参阅[为图像分配图像级标签](md-assign-image-level-labels.md)。您可以根据需要添加新标签。有关更多信息，请参阅 [管理标签](md-labels.md)。
## 查找物体位置
要创建预测图像中物体位置的模型，您需要为训练和测试数据集中的图像定义物体位置边界框和标签。边界框是紧紧围绕物体的方框。例如，下图显示了 Amazon Echo 和 Amazon Echo Dot 周围的边界框。每个边界框都有分配的标签（*Amazon Echo* 或 *Amazon Echo Dot*）。
![\[木质表面上有两个 Amazon 智能扬声器，一个带有绿色边界框，另一个带有蓝色边界框。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/echos.png)
要查找物体位置，数据集至少需要一个标签。在模型训练期间，会自动创建另一个标签，用于代表图像上边界框之外的区域。
### 分配边界框
创建数据集时，可以包含图像的边界框信息。例如，您可以导入包含边界框的 A SageMaker I Ground Truth 格式的[清单文件](md-create-manifest-file.md)。或者，也可以在创建数据集之后添加边界框。有关更多信息，请参阅 [使用边界框标注物体](md-localize-objects.md)。您可以根据需要添加新标签。有关更多信息，请参阅 [管理标签](md-labels.md)。
## 查找品牌位置
如果要查找品牌（例如徽标和动画角色）的位置，则可以为训练数据集图像使用两种不同类型的图像。
+ 仅包含徽标的图像。每张图像都需要一个代表徽标名称的图像级标签。例如，下图的图像级标签可以是 *Lambda*。
![\[橙色背景上的白色 Lambda 徽标。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/lambda-logo.jpg)
+ 在自然位置（例如足球比赛或架构图）包含徽标的图像。每张训练图像都需要围绕每个徽标实例的边界框。例如，下图显示了一张架构图，在 Lamb AWS da 和 Amazon Pinpoint 徽标周围带有标签的边界框。
![\[工作流图显示将用户活动输入 Amazon Pinpoint 以获取建议的 AWS Lambda 服务。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/brand-detection-lambda.png)
建议您不要在训练图像中混用图像级标签和边界框。
测试图像必须在您想要查找的品牌实例周围有边界框。只有当训练图像包含带标签的边界框时，才能拆分训练数据集来创建测试数据集。如果训练图像只有图像级标签，则必须创建一个测试数据集，该数据集中包含的图像必须具有带标签的边界框。如果训练模型来查找品牌位置，请根据为图像添加标签的方式执行以下操作：[使用边界框标注物体](md-localize-objects.md)和[为图像分配图像级标签](md-assign-image-level-labels.md)。
[品牌检测](getting-started.md#gs-brand-detection-example) 示例项目展示了 Amazon Rekognition Custom Labels 如何使用带标签的边界框来训练查找物体位置的模型。
## 不同模型类型的标签要求
根据下表确定如何为图像添加标签。
可以在单个数据集中混合带图像级标签的图像和包含带标签的边界框的图像。在这种情况下，Amazon Rekognition Custom Labels 会选择是创建图像级模型还是创建物体位置模型。
| 示例 | 训练图像 | 测试图像 |
| --- | --- | --- |
| [图像分类](#md-dataset-image-classification) | 每张图像 1 个图像级标签 | 每张图像 1 个图像级标签 |
| [多标签分类](#md-dataset-image-classification-multi-label) | 每张图像多个图像级标签 | 每张图像多个图像级标签 |
| [查找品牌位置](#md-dataset-purpose-brands) | 图像级标签（也可以使用带标签的边界框） | 带标签的边界框 |
| [查找物体位置](#md-dataset-purpose-localization) | 带标签的边界框 | 带标签的边界框 |
# 准备图像
训练和测试数据集中的图像包含您希望模型查找的物体、场景或概念。
图像的内容应采用各种背景和光线，以代表您希望经过训练的模型识别的图像。
本节提供训练和测试数据集中的图像的相关信息。
## 图像格式
可以使用 PNG 和 JPEG 格式的图像训练 Amazon Rekognition Custom Labels 模型。同样，要使用 `DetectCustomLabels` 检测自定义标签，您需要采用 PNG 和 JPEG 格式的图像。
## 输入图像建议
Amazon Rekognition Custom Labels 需要图像来训练和测试模型。准备图像时，请考虑以下几点：
+ 为要创建的模型选择一个特定的领域。例如，您可以为风景视图选择一个模型，为机器零件等物体选择另一个模型。当图像属于所选领域时，Amazon Rekognition Custom Labels 的效果最佳。
+ 使用不少于 10 张图像来训练模型。
+ 图像必须是 PNG 或 JPEG 格式。
+ 使用在各种光线、背景和分辨率下显示该物体的图像。
+ 训练和测试图像应与您要使用模型分析的图像相似。
+ 决定要为图像分配的标签。
+ 确保图像的分辨率足够大。有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。
+ 确保遮挡不会遮蔽要检测的物体。
+ 使用与背景对比鲜明的图像。
+ 使用明亮清晰的图像。尽量避免使用可能因拍摄主体和相机移动而模糊的图像。
+ 使用物体占图像很大比例的图像。
+ 测试数据集中的图像不应是训练数据集中的图像。这些图像应包含训练模型来分析的物体、场景和概念。
## 图像集大小
Amazon Rekognition Custom Labels 使用一组图像来训练模型。至少应使用 10 张图像进行训练。Amazon Rekognition Custom Labels 将训练和测试图像存储在数据集中。有关更多信息，请参阅 [使用图像创建训练和测试数据集](md-create-dataset.md)。
# 使用图像创建训练和测试数据集
可以从具有单个数据集的项目或者具有单独的训练和测试数据集的项目开始。如果从单个数据集开始，Amazon Rekognition Custom Labels 会在训练期间拆分该数据集，来为项目创建训练数据集 (80%) 和测试数据集 (%20)。如果想让 Amazon Rekognition Custom Labels 决定使用哪些图像进行训练和哪些图像进行测试，请从单个数据集开始。为了能够完全控制训练、测试和性能调整，建议您使用单独的训练数据集和测试数据集开始您的项目。
可以通过从以下位置之一导入图像来为项目创建训练和测试数据集：
+ [从 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 A SageMaker I Ground Truth 清单文件导入的图像已贴上标签。您可以使用 Amazon Rekognition Custom Labels 控制台添加、更改和分配标签。有关更多信息，请参阅 [标注图像](md-labeling-images.md)。
如果上传图像时出现错误、图像丢失或图像中缺少标签，请阅读[调试失败的模型训练](tm-debugging.md)。
有关数据集的更多信息，请参阅[管理数据集](managing-dataset.md)。
## 创建训练和测试数据集 (SDK)
您可以使用 AWS SDK 创建训练和测试数据集。
`CreateDataset` 操作允许您在创建新数据集时选择性地指定标签，以便对资源进行分类和管理。
### 训练数据集
您可以通过以下方式使用 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)。需要先添加数据集条目，然后才能训练模型。
### 测试数据集
您可以通过以下方式使用 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` 创建一个空的测试数据集。然后通过调用，将 20% 的训练数据集条目移到测试数据集中[DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries)。要创建空数据集，请参阅[向项目添加数据集 (SDK)](md-add-dataset.md#md-add-dataset-sdk)。要拆分训练数据集，请参阅[分配训练数据集 (SDK)](md-distributing-datasets.md)。
# 从 Amazon S3 存储桶导入图像
从 Amazon S3 存储桶中导入图像。您可以使用控制台存储桶或 AWS 账户中的其他 Amazon S3 存储桶。如果使用的是控制台存储桶，则所需权限已设置完毕。如果使用的不是控制台存储桶，请参阅[访问外部 Amazon S3 存储桶](su-console-policy.md#su-external-buckets)。
**注意**
您不能使用 AWS 软件开发工具包直接从 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*被分配了标签 e *cho-* dot。S3 文件夹位置 (*alexa-devices*) 层级的图像不会被分配标签。
可以通过指定更深层的 S3 文件夹位置，使用文件夹结构中的更深层文件夹来标注图像。例如，如果您指定 *S3 bucket/alexa-devices/echo-dot*，*white-echo-dot*则会标记*white-echo-dot*文件夹中的图像。不会导入指定 s3 文件夹位置（例如 *echo*）之外的图像。
```
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
├── .
└── .
```
我们建议您使用 Amazon Rekognition 在您首次在当前区域打开控制台时为您创建的 Amazon S3 存储桶（控制台存储桶）。 AWS 如果您使用的 Amazon S3 存储桶不是控制台存储桶，而是外部存储桶，则控制台会在创建数据集期间提示您设置适当的权限。有关更多信息，请参阅 [步骤 2：设置 Amazon Rekognition Custom Labels 控制台权限](su-console-policy.md)。
## 通过从 S3 存储桶导入图像来创建数据集
以下过程介绍如何使用存储在 S3 控制台存储桶中的图像来创建数据集。这些图像会自动使用存储它们的文件夹的名称进行标注。
导入图像后，就可以从数据集的图库页面添加更多图像、分配标签和添加边界框。有关更多信息，请参阅 [标注图像](md-labeling-images.md)。
**将图像上传到 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 管理控制台 并打开 Amazon S3 控制台，网址为[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 将您在步骤 1 中创建的[文件夹添加到](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)*首次设置*时由 Amazon Rekognition Custom Labels 为您创建的 Amazon S3 存储桶（控制台存储桶）中。有关更多信息，请参阅 [管理 Amazon Rekognition Custom Labels 项目](managing-project.md)。
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
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)中的步骤训练您的模型。
# 从本地计算机导入图像
直接从您的计算机加载图像。一次最多可以上传 30 张图像。
您上传的图像不会有与之关联的标签。有关更多信息，请参阅 [标注图像](md-labeling-images.md)。如果需要上传的图像很多，请考虑使用 Amazon S3 存储桶。有关更多信息，请参阅 [从 Amazon S3 存储桶导入图像](md-create-dataset-s3.md)。
**注意**
您不能使用 S AWS DK 创建包含本地图像的数据集。您可以创建一个清单文件，然后将图像上传到 Amazon S3 存储桶。有关更多信息，请参阅 [使用清单文件导入图像](md-create-dataset-ground-truth.md)。
**使用本地计算机上的图像创建数据集（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
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) 中的步骤，训练您的模型。
# 使用清单文件导入图像
您可以使用 Amazon A SageMaker I Ground Truth 格式的清单文件创建数据集。你可以使用 Amazon A SageMaker I Ground Truth 任务中的清单文件。如果您的图像和标签不是 SageMaker AI Ground Truth 清单文件的格式，则可以创建 A SageMaker I 格式的清单文件并使用它来导入已贴标签的图像。
`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 A SageMaker I 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 清单文件创建数据集（控制台）
以下过程向您展示如何使用 SageMaker AI Ground Truth 格式的清单文件创建数据集。
1. 通过执行下列操作之一，为训练数据集创建清单文件：
+ 按照中的说明创建包含 A SageMaker I GroundTruth Job 的清单文件[使用 Amazon A SageMaker I Ground Truth 作业为图片加标签](md-create-dataset-ground-truth-job.md)。
+ 按照[创建清单文件](md-create-manifest-file.md)中的说明创建您自己的清单文件。
如果要创建测试数据集，请重复步骤 1 以创建测试数据集。
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择要向其添加数据集的项目。此时将显示项目的详细信息页面。
1. 选择**创建数据集**。此时将显示**创建数据集**页面。
1. 在**开始配置**中，选择**从单个数据集开始**或**从训练数据集开始**。要创建更高质量的模型，建议从单独的训练和测试数据集开始。
------
#### [ Single dataset ]
1. 在**训练数据集详细信息**部分，选择**导入 SageMaker由 Ground Truth 标注的图像**。
1. 在 **.manifest 文件位置**中，输入您在步骤 1 中创建的清单文件的位置。
1. 选择**创建数据集**。这时会打开项目的数据集页面。
------
#### [ Separate training and test datasets ]
1. 在**训练数据集详细信息**部分，选择**导入 SageMaker由 Ground Truth 标注的图像**。
1. 在 **.manifest 文件位置**中，输入您在步骤 1 中创建的训练数据集清单文件的位置。
1. 在**测试数据集详细信息**部分，选择**导入 SageMaker 由 Ground Truth 标注的图像**。
**注意**
训练数据集和测试数据集可以有不同的图像源。
1. 在 **.manifest 文件位置**中，输入您在步骤 1 中创建的测试数据集清单文件的位置。
1. 选择**创建数据集**。这时会打开项目的数据集页面。
------
1. 如果需要添加或更改标签，请执行[标注图像](md-labeling-images.md)中的操作。
1. 按照[训练模型（控制台）](training-model.md#tm-console)中的步骤训练您的模型。
## 使用 SageMaker AI Ground Truth 清单文件 (SDK) 创建数据集
以下过程向您展示如何使用 [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 CLI 和 AWS SDKs。有关更多信息，请参阅 [步骤 4：设置 AWS CLI 和 AWS SDKs](su-awscli-sdk.md)。
1. 通过执行下列操作之一，为训练数据集创建清单文件：
+ 按照中的说明创建包含 A SageMaker I GroundTruth Job 的清单文件[使用 Amazon A SageMaker I Ground Truth 作业为图片加标签](md-create-dataset-ground-truth-job.md)。
+ 按照[创建清单文件](md-create-manifest-file.md)中的说明创建您自己的清单文件。
如果要创建测试数据集，请重复步骤 2 以创建测试数据集。
1. 使用以下示例代码创建训练和测试数据集。
------
#### [ AWS CLI ]
使用以下代码创建数据集。替换以下内容：
+ `project_arn`：要添加测试数据集的项目的 ARN。
+ `type`：要创建的数据集的类型（TRAIN 或 TEST）
+ `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: " + " \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)中的步骤训练您的模型。
## 创建数据集请求
以下是 CreateDataset 操作请求的格式：
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```
# 使用 Amazon A SageMaker I Ground Truth 作业为图片加标签
借助 SageMaker Amazon AI Ground Truth，你可以使用来自你选择的供应商公司 Amazon Mechanical Turk 的工作人员，也可以使用内部私人员工以及允许你创建一组带标签的图像的机器学习。亚马逊 Rekognition 自定义标签会从你指定的亚马逊 S3 存储桶中导入 SageMaker AI Ground Truth 清单文件。
亚马逊 Rekognition 自定义标签支持以下 A SageMaker I 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 任务创建清单文件（控制台）
以下过程向您展示如何使用由 SageMaker AI Ground Truth 作业标记的图像来创建数据集。该作业的输出文件存储在您的 Amazon Rekognition Custom Labels 控制台存储桶中。
**使用由 SageMaker AI Ground Truth 作业标记的图像创建数据集（控制台）**
1. 登录 AWS 管理控制台 并打开 Amazon S3 控制台，网址为[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在控制台存储桶中，[创建一个文件夹](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html)来存放训练图像。
**注意**
控制台存储桶是在您首次在某个地区打开 Amazon Rekognition 自定义标签控制台时创建的。 AWS 有关更多信息，请参阅 [管理 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 标注作业。您需要将 Amazon S3 URLs 用于您在步骤 2 和步骤 4 中创建的文件夹。有关更多信息，请参阅[使用 Amazon G SageMaker round Truth 进行数据标签](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html)。
1. 记下 `output.manifest` 文件在步骤 4 中创建的文件夹中的位置。它应该位于子文件夹 `Ground-Truth-Job-Name/manifests/output` 中。
1. 按照[使用 SageMaker AI Ground Truth 清单文件创建数据集（控制台）](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console)中的说明，使用上传的清单文件创建数据集。对于步骤 8，在 **.manifest 文件位置**中，输入您在上一步中记下的该位置的 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 作业。
# 创建清单文件
您可以通过导入 SageMaker AI Ground Truth 格式的清单文件来创建测试或训练数据集。如果您的图像的标签格式不是 SageMaker AI Ground Truth 清单文件，请使用以下信息创建 SageMaker AI Ground Truth 格式的清单文件。
清单文件采用 [JSON 行](http://jsonlines.org)格式，其中的每一行都是一个代表图像标注信息的完整 JSON 对象。亚马逊 Rekognition 自定义标签支持带有以下格式的 JSON 行的 SageMaker AI Ground Truth 清单：
+ [分类作业输出](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class)：用于向图像添加图像级标签。图像级标签定义了图像上的场景、概念或物体（如果不需要物体位置信息）的类别。一张图像可以有多个图像级标签。有关更多信息，请参阅 [在清单文件中导入图像级标签](md-create-manifest-file-classification.md)。
+ [边界框作业输出](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box)：用于标注图像上一个或多个物体的类别和位置。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
图像级和定位（边界框）JSON 行可在同一个清单文件中链接在一起。
**注意**
本部分的 JSON 行示例为便于阅读调整了格式。
当您导入清单文件时，Amazon Rekognition Custom Labels 会应用关于限制、语法和语义的验证规则。有关更多信息，请参阅 [清单文件的验证规则](md-create-manifest-file-validation-rules.md)。
清单文件引用的图像必须位于同一 Amazon S3 存储桶中。清单文件与图像可以位于不同于的 Amazon S3 存储桶中。您应在 JSON 行的 `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)
## 创建清单文件
以下过程创建包含训练和测试数据集的项目。这些数据集是从您创建的训练和测试清单文件创建的。
**使用 SageMaker AI Ground Truth 格式的清单文件创建数据集（控制台）**
1. 在控制台存储桶中，[创建一个文件夹](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html)来存放清单文件。
1. 在控制台存储桶中，创建一个文件夹来存放图像。
1. 上传图像至您刚才创建的文件夹。
1. 为您的训练数据集创建 A SageMaker I 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，在 **.manifest 文件位置**中，输入您在上一步中记下的该位置的 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 分类[作业输出](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class)格式 JOB 行添加到清单文件中。清单文件由一个或多个 JSON 行组成，每个行对应一张您要导入的图像。
**提示**
为了简化清单文件的创建，我们提供了从 CSV 文件创建清单文件的 Python 脚本。有关更多信息，请参阅 [从 CSV 文件创建清单文件](ex-csv-manifest.md)。
**创建图像级标签的清单文件**
1. 创建一个空文本文件。
1. 为要导入的每张图像各添加一个 JSON 行。每个 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 行
在本部分中，我们将介绍如何为单张图像创建 JSON 行。请考虑以下图像。下图的场景可能叫做 *Sunrise*。
![\[落日时分的湖面，有一个码头和几艘小船，周围群山环绕。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/sunrise.png)
上面这张包含 *Sunrise* 场景的图像的 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
（必需）图像的 Amazon S3 位置。格式为 `"s3://BUCKET/OBJECT_PATH"`。所导入数据集中的图像必须存储在同一 Amazon S3 存储桶中。
### *testdataset-classification\$1Sunrise*
（必需）标签属性。您选择的字段名称。该字段的值（在前面的示例中为 1）是标签属性的标识符。Amazon Rekognition Custom Labels 不使用它，它可以是任何整数值。必须有相应的元数据，这些元数据通过字段名称进行标识，并附有 *-metadata*。例如 `"testdataset-classification_Sunrise-metadata"`。
### *testdataset-classification\$1Sunrise*-元数据
（必需）与标签属性相关的元数据。该字段名称必须与标签属性附加 *-metadata* 之后相同。
*confidence*
（必需）Amazon Rekognition Custom Labels 目前未使用该属性，但必须为其提供介于 0 和 1 之间的值。
*job-name*
（可选）您为用于处理图像的作业选择的名称。
*class-name*
（必需）您为适用于图像的场景或概念选择的类别名称。例如 `"Sunrise"`。
*human-annotated*
（必需）如果注释由人工完成，请指定 `"yes"`。否则为 `"no"`。
*creation-date*
（必需）创建标签的协调世界时 (UTC) 日期和时间。
*type*
（必需）应该应用于图像的处理类型。对于图像级标签，该值为 `"groundtruth/image-classification"`。
### 为图像添加多个图像级标签
可以为图像添加多个标签。例如，以下 JSON 为单个图像添加两个标签：*football* 和 *ball*。
```
{
"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
```
# 清单文件中的物体定位
通过将 SageMaker AI Ground Truth [Box Job Output 格式 JOB](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) 行添加到清单文件中，你可以导入标有对象定位信息的图像。
定位信息表示物体在图像上的位置。该位置由围绕物体的边界框表示。边界框结构包含边界框的左上角坐标和边界框的宽度与高度。边界框格式的 JSON 行包含图像上一个或多个物体的位置的边界框以及图像上每个物体的类别。
清单文件由一个或多个 JSON 行组成，每行包含单张图像的信息。
**创建物体定位的清单文件**
1. 创建一个空文本文件。
1. 为要导入的每张图像各添加一个 JSON 行。每个 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 行
在本部分中，我们将介绍如何为单张图像创建 JSON 行。下图显示了 Amazon Echo 和 Amazon Echo Dot 设备周围的边界框。
![\[木质表面上有两个 Amazon 智能扬声器，一个带有绿色边界框，另一个带有蓝色边界框。\]](http://docs.aws.amazon.com/zh_cn/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
（必需）图像的 Amazon S3 位置。格式为 `"s3://BUCKET/OBJECT_PATH"`。所导入数据集中的图像必须存储在同一 Amazon S3 存储桶中。
### *bounding-box*
（必需）标签属性。您选择的字段名称。包含图像大小和图像中检测到的每个物体的边界框。必须有相应的元数据，这些元数据通过字段名称进行标识，并附有 *-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* 之后相同。图像中检测到的每个物体的边界框信息数组。
*Objects*
（必需）图像中的物体数组。按索引映射到 *annotations* 数组。Amazon Rekognition Custom Labels 不使用 confidence 属性。
*class-map*
（必需）适用于图像中检测到的物体的类别映射。
*type*
（必需）分类作业的类型。`"groundtruth/object-detection"` 将作业标识为物体检测。
*creation-date*
（必需）创建标签的协调世界时 (UTC) 日期和时间。
*human-annotated*
（必需）如果注释由人工完成，请指定 `"yes"`。否则为 `"no"`。
*job-name*
（可选）处理图像的作业的名称。
# 清单文件的验证规则
当您导入清单文件时，Amazon Rekognition Custom Labels 会应用关于限制、语法和语义的验证规则。 SageMaker AI Ground Truth 架构强制执行语法验证。有关更多信息，请参阅[输出](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html)。以下是限制和语义的验证规则。
**注意**
所有验证规则累计遵循 20% 的无效规则。如果由于任意组合（例如 15% 的无效 JSON 和 15% 的无效图像）导致导入超过 20% 的限制，则导入将失败。
每个数据集对象都对应于清单中的一行。空行/无效行也算作数据集对象。
重叠度为（测试和训练之间的共用标签数）/（训练标签数）。
**Topics**
+ [限制](#md-validation-rules-limits)
+ [语义](#md-validation-rules-semantics)
## 限制
| 验证 | 限制 | 出现错误 |
| --- | --- | --- |
| 清单文件大小 | 最大 1 GB | 错误 |
| 清单文件的最大行数 | 一个清单中最多可以包含 250,000 个数据集对象行。 | 错误 |
| 每个标签的有效数据集对象总数的下限 | >=1 | 错误 |
| 标签数下限 | >=2 | 错误 |
| 标签数上限 | <=250 | 错误 |
| 每张图像的最小边界框数 | 0 | 无 |
| 每张图像的最大边界框数 | 50 | 无 |
## 语义
| 验证 | 限制 | 出现错误 |
| --- | --- | --- |
| 空清单 | | 错误 |
| source-ref 对象丢失/无法访问 | 对象数量小于 20% | 警告 |
| source-ref 对象丢失/无法访问 | 对象数量 > 20% | 错误 |
| 训练数据集中不存在测试标签 | 标签中至少有 50% 的重叠 | 错误 |
| 在数据集中混合标签与同一标签的对象示例。针对同一类别在数据集对象中进行分类和检测。 | | 没有错误或警告 |
| 测试与训练之间的重叠资产 | 测试数据集与训练数据集之间不应有重叠。 | |
| 数据集中的图像必须来自同一个存储桶 | 如果对象位于不同的存储桶中，则会出错 | 错误 |
# 将其他数据集格式转换为清单文件
您可以使用以下信息从各种源数据集格式创建 SageMaker Amazon 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 数据集转换为清单文件格式
[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 文件由五个部分组成，提供了*整个数据集*的信息。有关更多信息，请参阅 [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)：标签类别列表。
您需要来自 `images`、`annotations` 和 `categories` 列表的信息，才能创建 Amazon Rekognition Custom Labels 清单文件。
Amazon Rekognition Custom Labels 清单文件采用 JSON 行格式，其中每行都包含了*一张图像上*的一个或多个物体的边界框和标签信息。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
## 将 COCO 对象映射到自定义标签 JSON 行
要转换 COCO 格式的数据集，需要将 COCO 数据集映射到 Amazon Rekognition Custom Labels 清单文件以进行物体定位。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。要为每张图片构建 JSON 行，清单文件需要映射 COCO 数据集`image`和`category`对象字段 IDs。`annotation`
下面是一个 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、作业和作业元数据字段。匹配的颜色表示单张图像的信息。请注意，在清单中，一张图像可能有多个注释和元数据/类别。
![\[图中显示 COCO 清单的结构，其中包含图像、注释和类别。\]](http://docs.aws.amazon.com/zh_cn/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. 重复步骤 1-3，直到为 `image` 列表中的每个 `images` 对象创建 JSON 行。
有关示例代码，请参阅[转换 COCO 数据集](md-coco-transform-example.md)。
## 将 COCO 对象字段映射到自定义标签 JSON 行对象字段
确定 Amazon Rekognition Custom Labels JSON 行的 COCO 对象后，需要将 COCO 对象字段映射到相应的 Amazon Rekognition Custom Labels JSON 行对象字段。以下示例 Amazon Rekognition Custom Labels JSON 行将一张图像 (`id`=`000000245915`) 映射到上面的 COCO JSON 示例。请注意以下信息。
+ `source-ref` 是图像在 Amazon S3 存储桶中的位置。如果 COCO 图像不是存储在 Amazon S3 存储桶中，则需要将它们移到 Amazon S3 存储桶中。
+ `annotations` 列表中包含了图像上每个物体的 `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
图像位置的 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*
您选择的标签属性名称。有关更多信息，请参阅 [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box)。
#### image\$1size
图像大小（以像素为单位）。映射到 [images](md-coco-overview.md#md-coco-images) 列表中的 `image` 对象。
+ `height`-> `image.height`
+ `width`-> `image.width`
+ `depth`：Amazon Rekognition Custom Labels 未使用该属性，但必须为其提供一个值。
#### annotations
`annotation` 对象的列表。图像上的每个物体都有一个 `annotation`。
#### annotation
包含图像上物体的一个实例的边界框信息。
+ `class_id`：映射到自定义标签的 `class-map` 列表的数字 ID。
+ `top` -> `bbox[1]`
+ `left` -> `bbox[0]`
+ `width` -> `bbox[2]`
+ `height` -> `bbox[3]`
### *bounding-box*-元数据
标签属性的元数据。包含标签和标签标识符。有关更多信息，请参阅 [*bounding-box*-元数据](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata)。
#### Objects
图像中的物体数组。按索引映射到 `annotations` 列表。
##### Object
+ Amazon Rekognition Custom Labels 未使用该属性，但必须为其指定值 (1)。
#### class-map
适用于图像中检测到的物体的标签（类别）映射。映射到 [categories](md-coco-overview.md#md-coco-categories) 列表中的 category 对象。
+ `id` -> `category.id`
+ `id value` -> `category.name`
#### 类型
必须是 `groundtruth/object-detection`
#### human-annotated
指定 `yes` 或 `no`。有关更多信息，请参阅 [*bounding-box*-元数据](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
图像的创建日期和时间。映射到 COCO 图像列表中的图像的 [image](md-coco-overview.md#md-coco-images).date\$1captured 字段。Amazon Rekognition Custom Labels 期望的 `creation-date` 格式为 *Y-M-DTH:M:S*。
#### job-name
您选择的作业名称。
# COCO 数据集格式
COCO 数据集由五个信息部分组成，提供了整个数据集的信息。COCO 物体检测数据集的格式记录在 [COCO 数据格式](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"}
]
}
```
## 图像列表
COCO 数据集引用的图像列在图像数组中。每个图像对象都包含了有关该图像的信息，例如图像文件名。在以下示例图像对象中，请注意以下信息以及创建 Amazon Rekognition Custom Labels 清单文件需要哪些字段。
+ `id`：（必需）图像的唯一标识符。`id` 字段映射到注释数组（存储边界框信息的地方）中的 `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"
}
```
## 注释（边界框）列表
所有图像上的所有物体的边界框信息都存储在注释列表中。单个注释对象包含单个物体的边界框信息以及该物体在图像上的标签。图像上物体的每个实例都有一个注释对象。
在以下示例中，请注意以下信息以及创建 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]
}
```
## 类别列表
标签信息存储在类别数组中。在以下示例类别对象中，请注意以下信息以及创建 Amazon Rekognition Custom Labels 清单文件需要哪些字段。
+ `supercategory`：（非必需）标签的父类别。
+ `id`：（必需）标签标识符。`id` 字段映射到 `annotation` 对象中的 `category_id` 字段。在以下示例中，echo dot 的标识符为 2。
+ `name`：（必需）标签名称。
```
{"supercategory": "speaker","id": 2,"name": "echo dot"}
```
# 转换 COCO 数据集
使用以下 Python 示例将边界框信息从 COCO 格式的数据集转换为 Amazon Rekognition Custom Labels 清单文件。该代码会将创建的清单文件上载到您的 Amazon S3 存储桶。该代码还提供了一个 AWS CLI 命令，您可以使用该命令上传您的图像。
**转换 COCO 数据集 (SDK)**
1. 如果您尚未执行以下操作，请：
1. 确保您具有 `AmazonS3FullAccess` 权限。有关更多信息，请参阅 [设置 SDK 权限](su-sdk-permissions.md)。
1. 安装并配置 AWS CLI 和 AWS SDKs。有关更多信息，请参阅 [步骤 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`) 中将要放置自定义标签清单文件的位置的路径。
+ `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，在 **.manifest 文件位置**中，输入您在上一步中记下的 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 清单文件
本主题向您展示如何将多标签 Amazon A SageMaker I Ground Truth 清单文件转换为亚马逊 Rekognition 自定义标签格式的清单文件。
SageMaker 多标签作业的 AI Ground Truth 清单文件的格式与 Amazon Rekognition 自定义标签格式清单文件的格式不同。多标签分类是指将一个图像分类为一组类别，但可能同时属于多个类别。在这种情况下，该图像可能会有多个标签（多标签），例如 *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)。
## 获取 A SageMaker I Ground Truth 任务的清单文件
以下过程向您展示了如何获取 Amazon A SageMaker I Ground Truth 任务的输出清单文件 (`output.manifest`)。您可以将 `output.manifest` 用作下一过程的输入。
**下载 A SageMaker I 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 清单文件
以下过程根据现有的多标签格式 AI 清单文件创建多标签格式 Amazon Rekognition 自定义标签清单文件。 SageMaker GroundTruth
**注意**
要运行此代码，您需要使用 Python 版本 3 或更高版本。
**转换多标签 SageMaker AI 清单文件**
1. 运行以下 Python 代码。提供您在[获取 A SageMaker I 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. [上传清单文件](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)至要用于存储清单文件的 Amazon S3 存储桶。
**注意**
确保 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，在 **.manifest 文件位置**中，请输入清单文件位置的 Amazon S3 URL。如果使用的是 AWS SDK，请执行[使用 SageMaker AI Ground Truth 清单文件 (SDK) 创建数据集](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk)。
# 从 CSV 文件创建清单文件
此示例 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)的清单文件。
清单文件描述了用于训练模型的图像。例如，图像位置和分配给图像的标签。清单文件由一个或多个 JSON 行组成。每个 JSON 行都描述了一张图像。有关更多信息，请参阅 [在清单文件中导入图像级标签](md-create-manifest-file-classification.md)。
CSV 文件代表文本文件中多行的表格数据。一行中的各个字段用逗号分隔。有关更多信息，请参阅[逗号分隔的值](https://en.wikipedia.org/wiki/Comma-separated_values)。对于此脚本，CSV 文件中的每一行都代表一张图像，并映射到清单文件中的一个 JSON 行。要为支持[多标签图像分类](getting-started.md#gs-multi-label-image-classification-example)的清单文件创建 CSV 文件，您需要向每行添加一个或多个图像级标签。要创建适用于[图像分类](getting-started.md#gs-image-classification-example)的清单文件，请在每行中添加一个图像级标签。
例如，以下 CSV 文件描述了[多标签图像分类](getting-started.md#gs-multi-label-image-classification-example) (Flowers) *入门*项目中的图像。
```
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 行。例如，以下是第一行 (`camellia1.jpg,camellia,with_leaves`) 的 JSON 行。
```
{"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 文件和重复的图像 CSVfile，因为它们为空。
在此过程中，您将创建 CSV 文件并运行 Python 脚本以创建清单文件。
**通过 CSV 文件创建清单文件**
1. 创建一个 CSV 文件，并且在每一行中包含以下字段（每张图像占一行）。请勿在 CSV 文件中添加标题行。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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/`：要添加到图像文件名（字段 1）的 Amazon S3 路径。如果字段 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. [上传清单文件](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)至要用于存储清单文件的 Amazon S3 存储桶。
**注意**
确保 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，在 **.manifest 文件位置**中，请输入清单文件位置的 Amazon S3 URL。如果使用的是 AWS SDK，请执行[使用 SageMaker AI Ground Truth 清单文件 (SDK) 创建数据集](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk)。
# 复制现有数据集的内容
如果您之前已创建数据集，可以将其内容复制到新数据集中。要使用 S AWS DK 根据现有数据集创建数据集，请参阅[使用现有数据集创建数据集 (SDK)](md-create-dataset-existing-dataset-sdk.md)。
**使用现有的 Amazon Rekognition Custom Labels 数据集创建数据集（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
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)中的步骤训练您的模型。
# 标注图像
标签用于标识图像中的物体、场景、概念或物体周围的边界框。例如，如果数据集包含狗的图像，则可以添加表示犬种的标签。
将图像导入数据集后，您可能需要为图像添加标签或更正标注错误的图像。例如，从本地计算机导入的图像就没有标签。可以使用数据集库向数据集添加新标签，并为数据集中的图像分配标签和边界框。
如何为数据集中的图像添加标签决定了 Amazon Rekognition Custom Labels 训练的模型的类型。有关更多信息，请参阅 [确定数据集用途](md-dataset-purpose.md)。
**Topics**
+ [管理标签](md-labels.md)
+ [为图像分配图像级标签](md-assign-image-level-labels.md)
+ [使用边界框标注物体](md-localize-objects.md)
# 管理标签
可以使用 Amazon Rekognition Custom Labels 控制台管理标签。没有用于管理标签的特定 API - 当您使用 `CreateDataset` 创建数据集或使用 `UpdateDatasetEntries` 向数据集添加更多图像时，便会将标签添加到数据集中。
**Topics**
+ [管理标签（控制台）](#md-labels-console)
+ [管理标签 (SDK)](#md-labels-sdk)
## 管理标签（控制台）
可以使用 Amazon Rekognition Custom Labels 控制台从数据集中添加、更改或移除标签。要向数据集添加标签，您可以在 Rekognition 中添加自己创建的新标签或从现有数据集导入标签。
**Topics**
+ [添加新标签（控制台）](#md-add-new-labels)
+ [更改和移除标签（控制台）](#md-edit-labels-after-adding)
### 添加新标签（控制台）
您可以指定要添加到数据集的新标签。
#### 使用编辑窗口添加标签
**添加新标签（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择要使用的项目。此时将显示项目的详细信息页面。
1. 如果要向训练数据集添加标签，请选择**训练**选项卡。否则，请选择**测试**选项卡，向测试数据集添加标签。
1. 选择**开始标注**，进入标注模式。
1. 在数据集库的**标签**部分，选择**管理标签**，打开**管理标签**对话框。
1. 在编辑框中，输入新标签名称。
1. 选择**添加标签**。
1. 重复步骤 9 和 10，直到创建完所需的所有标签。
1. 选择**保存**，保存您添加的标签。
### 更改和移除标签（控制台）
将标签添加到数据集后，可以对其进行重命名或移除。只能移除尚未分配给任何图像的标签。
**重命名或移除现有标签（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择要使用的项目。此时将显示项目的详细信息页面。
1. 如果要更改或删除训练数据集中的标签，请选择**训练**选项卡。否则，请选择**测试**选项卡，以更改或删除测试数据集中的标签。
1. 选择**开始标注**，进入标注模式。
1. 在数据集库的**标签**部分，选择**管理标签**，打开**管理标签**对话框。
1. 选择要编辑或删除的标签。
![\[“管理标签”对话框显示一个文本字段用于添加新标签和名为“test”的现有标签，并提供用于保存或取消更改的选项。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/change-delete-label.jpg)
1. 如果选择删除图标 (X)，则会从列表中移除标签。
1. 如果要更改标签，请选择编辑图标（铅笔和便签组合成的图标），然后在编辑框中输入新标签名称。
1. 选择**保存**，保存您的更改。
## 管理标签 (SDK)
没有专门的 API 来管理数据集标签。如果使用 `CreateDataset`、在清单文件中找到的标签或复制的数据集来创建数据集，则会创建初始标签集。如果使用 `UpdateDatasetEntries` API 添加更多图像，则会将在这些条目中发现的新标签添加到数据集中。有关更多信息，请参阅 [添加更多图像 (SDK)](md-add-images.md#md-add-images-sdk)。要从数据集中删除标签，必须移除数据集中的所有标签注释。
**删除数据集中的标签**
1. 调用 `ListDatasetEntries` 获取数据集条目。有关示例代码，请参阅[列出数据集条目 (SDK)](md-listing-dataset-entries-sdk.md)。
1. 在文件中，移除所有标签注释。有关更多信息，请参阅[在清单文件中导入图像级标签](md-create-manifest-file-classification.md)和[清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
1. 使用该文件通过 `UpdateDatasetEntries` API 更新数据集。有关更多信息，请参阅 [添加更多图像 (SDK)](md-add-images.md#md-add-images-sdk)。
# 为图像分配图像级标签
可以使用图像级标签来训练将图像分类的模型。图像级标签表示图像包含物体、场景或概念。例如，下图显示了一条河。如果模型将图像分类为包含河流，则需要添加 *river* 图像级标签。有关更多信息，请参阅 [确定数据集用途](md-dataset-purpose.md)。
![\[日落或日出时分，群山和云层倒映在平静的湖面上。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/pateros.jpg)
包含图像级标签的数据集需要至少定义两个标签。每张图像都至少需要分配一个用于标识图像中的物体、场景或概念的标签。
**为图像分配图像级标签（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择要使用的项目。此时将显示项目的详细信息页面。
1. 在左侧导航窗格中，选择**数据集**。
1. 如果要向训练数据集添加标签，请选择**训练**选项卡。否则，请选择**测试**选项卡，向测试数据集添加标签。
1. 选择**开始标注**，进入标注模式。
1. 在图像库中，选择要为其添加标签的一张或多张图像。一次只能选择一个页面上的图像。要在一个页面上选择连续范围的图像，请执行以下操作：
1. 选择范围中的第一张图像。
1. 按住 Shift 键。
1. 选择范围中的最后一张图像。这样便可将第一张和第二张图像之间的图像全部选中。
1. 松开 Shift 键。
1. 选择**分配图像级标签**。
1. 在**向选定图像分配图像级标签**对话框中，选择要分配给该等图像的标签。
1. 选择**分配**，将标签分配给图像。
1. 重复标注，直到每张图像都用所需的标签进行注释。
1. 选择**保存更改**以保存您的更改。
## 分配图像级标签 (SDK)
可以使用 `UpdateDatasetEntries` API 添加或更新分配给图像的图像级标签。`UpdateDatasetEntries` 接受一个或多个 JSON 行。每个 JSON 行代表一张图像。对于带有图像级标签的图像，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"}}
```
`source-ref` 字段表示图像的位置。JSON 行还包含分配给图像的图像级标签。有关更多信息，请参阅 [在清单文件中导入图像级标签](md-create-manifest-file-classification.md)。
**为图像分配图像级标签**
1. 使用 `ListDatasetEntries` 获取现有图像的 JSON 行。在 `source-ref` 字段中，指定要为其分配标签的图像的位置。有关更多信息，请参阅 [列出数据集条目 (SDK)](md-listing-dataset-entries-sdk.md)。
1. 按照[在清单文件中导入图像级标签](md-create-manifest-file-classification.md)中的信息更新上一步中返回的 JSON 行。
1. 调用 `UpdateDatasetEntries` 来更新图像。有关更多信息，请参阅 [向数据集中添加更多图像](md-add-images.md)。
# 使用边界框标注物体
如果要让模型检测图像中物体的位置，则必须标识物体是什么以及它在图像中的位置。边界框是用来隔离图像中物体的方框。可以使用边界框来训练模型以检测同一图像中的不同物体。可以通过为边界框分配标签来标识物体。
**注意**
如果要训练模型查找带有图像级标签的物体、场景和概念，则无需执行此步骤。
例如，如果要训练检测 Amazon Echo Dot 设备的模型，则可以在图像中的每个 Echo Dot 周围绘制一个边界框，再为边界框分配名为 *Echo Dot* 的标签。下图显示了 Echo Dot 设备周围的边界框。该图像还包含了一个没有边界框的 Amazon Echo。
![\[Amazon Echo Dot 和 Echo 设备，Echo Dot 周围有边界框。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/dot.jpg)
## 使用边界框定位物体（控制台）
在此过程中，您将使用控制台在图像中物体的周围绘制边界框。您还可以通过为边界框分配标签来标识图像中的物体。
**注意**
不能使用 Safari 浏览器为图像添加边界框。有关支持的浏览器，请参阅[设置 Amazon Rekognition Custom Labels](setting-up.md)。
在添加边界框之前，必须至少向数据集添加一个标签。有关更多信息，请参阅 [添加新标签（控制台）](md-labels.md#md-add-new-labels)。
****
**向图像添加边界框（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择要使用的项目。此时将显示项目的详细信息页面。
1. 在项目详细信息页面上，选择**对图像进行贴标**
1. 如果要向训练数据集图像添加边界框，请选择**训练**选项卡。否则，请选择**测试**选项卡，向测试数据集图像添加边界框。
1. 选择**开始标注**，进入标注模式。
1. 在图像库中，选择要向其添加边界框的图像。
1. 选择**绘制边界框**。在显示边界框编辑器之前，会显示一系列提示。
1. 在右侧的**标签**窗格中，选择要分配给边界框的标签。
1. 在绘图工具中，将指针放在所需物体的左上角区域。
1. 按住鼠标左键，在物体周围绘制一个方框。尝试将边界框绘制得尽量靠近物体。
1. 松开鼠标键。该边界框会突出显示。
1. 如果有更多图像需要标注，请选择**下一步**。否则，请选择**完成**，完成标注。
![\[UI 可用于在图像周围绘制边界框，图中所示为木质表面上的 Amazon Echo 和 Echo Dot 智能扬声器。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/draw-bounding-box.png)
1. 重复步骤 1—7，直到在每张包含物体的图像中都创建了一个边界框。
1. 选择**保存更改**以保存您的更改。
1. 选择**退出**，退出标注模式。
## 使用边界框定位物体 (SDK)
可以使用 `UpdateDatasetEntries` API 来添加或更新图像的物体位置信息。`UpdateDatasetEntries` 接受一个或多个 JSON 行。每个 JSON 行代表一张图像。对于物体定位，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"}}
```
`source-ref` 字段表示图像的位置。JSON 行还包含了图像上每个物体的带标签的边界框。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
**为图像分配边界框**
1. 使用 `ListDatasetEntries` 获取现有图像的 JSON 行。在 `source-ref` 字段中，指定要为其分配图像级标签的图像的位置。有关更多信息，请参阅 [列出数据集条目 (SDK)](md-listing-dataset-entries-sdk.md)。
1. 按照[清单文件中的物体定位](md-create-manifest-file-object-detection.md)中的信息更新上一步中返回的 JSON 行。
1. 调用 `UpdateDatasetEntries` 来更新图像。有关更多信息，请参阅 [向数据集中添加更多图像](md-add-images.md)。
# 调试数据集
在数据集创建过程中，可能会发生两种类型的错误：*终止性错误*和*非终止性错误*。终止性错误可能会停止数据集的创建或更新。非终止性错误不会停止数据集的创建或更新。
**Topics**
+ [调试终止性数据集错误](debugging-datasets-terminal-errors.md)
+ [调试非终止性数据集错误](debugging-datasets-non-terminal-errors.md)
# 调试终止性数据集错误
终止性错误有两种类型：导致数据集创建失败的文件错误，以及 Amazon Rekognition Custom Labels 从数据集中移除的内容错误。如果内容错误太多，数据集创建会失败。
**Topics**
+ [终止性文件错误](#debugging-datasets-terminal-file-errors)
+ [终止性内容错误](#debugging-datasets-terminal-content-errors)
## 终止性文件错误
以下是文件错误。可以通过调用 `DescribeDataset` 并检查 `Status` 和 `StatusMessage` 字段来获取有关文件错误的信息。有关示例代码，请参阅[描述数据集 (SDK)](md-describing-dataset-sdk.md)。
+ [ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT](#md-error-status-ERROR_MANIFEST_INACCESSIBLE_OR_UNSUPPORTED_FORMAT)
+ [ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE](#md-error-status-ERROR_MANIFEST_SIZE_TOO_LARGE).
+ [ERROR\$1MANIFEST\$1ROWS\$1EXCEEDS\$1MAXIMUM](#md-error-status-ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM)
+ [ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET](#md-error-status-ERROR_INVALID_PERMISSIONS_MANIFEST_S3_BUCKET)
+ [ERROR\$1TOO\$1MANY\$1RECORDS\$1IN\$1ERROR](#md-error-status-ERROR_TOO_MANY_RECORDS_IN_ERROR)
+ [ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS](#md-error-status-ERROR_MANIFEST_TOO_MANY_LABELS)
+ [ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1DISTRIBUTE](#md-error-status-ERROR_INSUFFICIENT_IMAGES_PER_LABEL_FOR_DISTRIBUTE)
### ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT
#### 错误消息
清单文件扩展名或内容无效。
训练或测试清单文件没有文件扩展名或其内容无效。
**修复错误 *ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT***
+ 在训练和测试清单文件中检查以下可能的原因。
+ 清单文件缺少文件扩展名。按照惯例，文件扩展名为 `.manifest`。
+ 找不到清单文件的 Amazon S3 存储桶或密钥。
### ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE
#### 错误消息
清单文件大小超过了支持的最大大小。
训练或测试清单文件大小（以字节为单位）太大。有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。清单文件可能会 JSON 行数少于最大值，但文件大小超过最大值。
无法使用 Amazon Rekognition Custom Labels 控制台修复错误：*清单文件大小超过了支持的最大大小*。
**修复错误 *ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE***
1. 检查哪些训练和测试清单文件超过了最大文件大小。
1. 减少过大的清单文件中的 JSON 行数。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
### ERROR\$1MANIFEST\$1ROWS\$1EXCEEDS\$1MAXIMUM
#### 错误消息
清单文件中的行数太多。
#### 更多信息
清单文件中的 JSON 行数（图像数）大于允许的限制。图像级模型和物体位置模型的限制不同。有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。
系统会验证 JSON 行错误，直至 JSON 行数达到 `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM` 限制。
无法使用 Amazon Rekognition Custom Labels 控制台修复 `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM` 错误。
**修复 `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`**
+ 减少清单中的 JSON 行数。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
### ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET
#### 错误消息
S3 存储桶权限不正确。
Amazon Rekognition Custom Labels 不具有对一个或多个包含训练和测试清单文件的存储桶的权限。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复错误 *ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET***
+ 检查对包含训练和测试清单的存储桶的权限。有关更多信息，请参阅 [步骤 2：设置 Amazon Rekognition Custom Labels 控制台权限](su-console-policy.md)。
### ERROR\$1TOO\$1MANY\$1RECORDS\$1IN\$1ERROR
#### 错误消息
清单文件有太多终止性错误。
**修复 `ERROR_TOO_MANY_RECORDS_IN_ERROR`**
+ 减少有终止性内容错误的 JSON 行（图像）的数量。有关更多信息，请参阅 [终止性清单内容错误](tm-debugging-aggregate-errors.md)。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
### ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS
#### 错误消息
清单文件包含的标签太多。
##### 更多信息
清单（数据集）中唯一标签的数量超过了允许的限制。如果拆分训练数据集来创建测试数据集，则标签数量将在拆分后确定。
**修复 ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS（控制台）**
+ 从数据集中移除标签。有关更多信息，请参阅 [管理标签](md-labels.md)。标签会自动从数据集中的图像和边界框中移除。
**修复 ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS（JSON 行）**
+ 清单包含图像级 JSON 行 - 如果图像只有一个标签，请移除使用所需标签的图像对应的 JSON 行。如果相关 JSON 行包含多个标签，请仅移除所需标签对应的 JSON 对象。有关更多信息，请参阅 [为图像添加多个图像级标签](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels)。
清单包含物体位置 JSON 行 - 移除要移除的标签所对应的边界框和关联的标签信息。对包含所需标签的每个 JSON 行执行此操作。需要从 `class-map` 数组中移除标签并从 `objects` 和 `annotations` 数组中移除相应的对象。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
### ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1DISTRIBUTE
#### 错误消息
清单文件中没有足够的带标签的图像来分配数据集。
当 Amazon Rekognition Custom Labels 拆分训练数据集来创建测试数据集时，就会发生数据集分配。也可以通过调用 `DistributeDatasetEntries` API 来拆分数据集。
**修复错误 *ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS***
+ 向训练数据集中添加更多带标签的图像
## 终止性内容错误
以下是终止性内容错误。在创建数据集的过程中，会从数据集中移除包含终止性内容错误的图像。该数据集仍可用于训练。如果内容错误太多， dataset/update 则失败。与数据集操作相关的终止性内容错误不会显示在控制台中，也不会从 `DescribeDataset` 或其他 API 返回。如果您发现数据集中缺少图像或注释，请检查您的数据集清单文件是否存在以下问题：
+ JSON 行的长度太长。最大长度为 100,000 个字符。
+ JSON 行中缺少 `source-ref` 值。
+ JSON 行中 `source-ref` 值的格式无效。
+ JSON 行的内容无效。
+ 一个 `source-ref` 字段值出现了多次。一张图像在一个数据集中只能被引用一次。
有关 `source-ref` 字段的信息，请参阅[创建清单文件](md-create-manifest-file.md)。
# 调试非终止性数据集错误
以下是在数据集创建或更新过程中可能发生的非终止性错误。这些错误可能会使整个 JSON 行失效或使 JSON 行中的注释失效。如果 JSON 行有错误，则不会将其用于训练。如果 JSON 行中的注释有错误，仍会将该 JSON 行用于训练，但不包括损坏的注释。有关 JSON 行的更多信息，请参阅[创建清单文件](md-create-manifest-file.md)。
可以通过控制台以及通过调用 `ListDatasetEntries` API 来访问非终止性错误。有关更多信息，请参阅 [列出数据集条目 (SDK)](md-listing-dataset-entries-sdk.md)。
训练期间还会返回以下错误。建议您在训练模型之前先修复这些错误。有关更多信息，请参阅[非终止性 JSON 行验证错误](tm-debugging-json-line-errors.md)。
+ [ERROR\$1NO\$1LABEL\$1ATTRIBUTES](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_LABEL_ATTRIBUTES)
+ [ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1FORMAT](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_ATTRIBUTE_FORMAT)
+ [ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1METADATA\$1FORMAT](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_ATTRIBUTE_METADATA_FORMAT)
+ [ERROR\$1NO\$1VALID\$1LABEL\$1ATTRIBUTES](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_VALID_LABEL_ATTRIBUTES)
+ [ERROR\$1INVALID\$1BOUNDING\$1BOX](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_BOUNDING_BOX)
+ [ERROR\$1INVALID\$1IMAGE\$1DIMENSION](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_IMAGE_DIMENSION)
+ [ERROR\$1BOUNDING\$1BOX\$1TOO\$1SMALL](tm-debugging-json-line-errors.md#tm-error-ERROR_BOUNDING_BOX_TOO_SMALL)
+ [ERROR\$1NO\$1VALID\$1ANNOTATIONS](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_VALID_ANNOTATIONS)
+ [ERROR\$1MISSING\$1BOUNDING\$1BOX\$1CONFIDENCE](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_BOUNDING_BOX_CONFIDENCE)
+ [ERROR\$1MISSING\$1CLASS\$1MAP\$1ID](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_CLASS_MAP_ID)
+ [ERROR\$1TOO\$1MANY\$1BOUNDING\$1BOXES](tm-debugging-json-line-errors.md#tm-error-ERROR_TOO_MANY_BOUNDING_BOXES)
+ [ERROR\$1UNSUPPORTED\$1USE\$1CASE\$1TYPE](tm-debugging-json-line-errors.md#tm-error-ERROR_UNSUPPORTED_USE_CASE_TYPE)
+ [ERROR\$1INVALID\$1LABEL\$1NAME\$1LENGTH](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_NAME_LENGTH)
## 访问非终止性错误
可以使用控制台来找出数据集中存在非终止性错误的图像。也可以调用 `ListDatasetEntries` API 来获取错误消息。有关更多信息，请参阅 [列出数据集条目 (SDK)](md-listing-dataset-entries-sdk.md)。
**访问非终止性错误（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择要使用的项目。此时将显示项目的详细信息页面。
1. 如果要查看训练数据集中的非终止性错误，请选择**训练**选项卡。否则，请选择**测试**选项卡，以查看测试数据集中的非终止性错误。
1. 在数据集库的**标签**部分，选择**错误**。数据集库经过筛选，仅显示有错误的图像。
1. 选择图像下方的**错误**以查看错误代码。按照[非终止性 JSON 行验证错误](tm-debugging-json-line-errors.md)中的说明修复错误。
![\[错误对话框的“数据集记录错误”下显示“ERROR_UNSUPPORTED_USE_CASE_TYPE”和“ERROR_NO_VALID_LABEL_ATTRIBUTES”。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/dataset-non-terminal-error.jpg)
# 训练 Amazon Rekognition Custom Labels 模型
可以使用 Amazon Rekognition Custom Labels 控制台或 Amazon Rekognition Custom Labels API 来训练模型。如果模型训练失败，请按照[调试失败的模型训练](tm-debugging.md)中的说明查找失败的原因。
**注意**
您需要按照成功训练模型所花费的时间付费。通常，训练需要 30 分钟到 24 小时才能完成。有关更多信息，请参阅[训练时长](https://aws.amazon.com/rekognition/pricing/#Amazon_Rekognition_Custom_Labels_pricing)。
每次训练模型都会创建一个新的模型版本。Amazon Rekognition Custom Labels 会为模型创建一个名称，该名称是项目名称和模型创建时的时间戳的组合。
为了训练您的模型，Amazon Rekognition Custom Labels 会复制您的源训练图像和测试图像。默认情况下，复制的图像使用 AWS 拥有和管理的密钥进行静态加密。您也可以选择使用自己的 AWS KMS key。如果使用自己的 KMS 密钥，则需要对该 KMS 密钥具有以下权限。
+ kms: CreateGrant
+ kms: DescribeKey
有关更多信息，请参阅 [AWS Key Management Service 概念](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)。源图像不受影响。
可以使用 KMS 服务器端加密 (SSE-KMS) 加密 Amazon S3 存储桶中的训练和测试图像，然后再将它们复制到 Amazon Rekognition Custom Labels 中。要允许 Amazon Rekognition 自定义标签访问您的图片 AWS ，您的账户需要对 KMS 密钥拥有以下权限。
+ kms: GenerateDataKey
+ kms:Decrypt
有关更多信息，请参阅[使用存储在 AWS Key Management Service 中的 KMS 密钥通过服务器端加密 (SSE-KMS) 保护数据](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)。
训练模型后，您可以评估其性能并进行改进。有关更多信息，请参阅 [改进经过训练的 Amazon Rekognition Custom Labels 模型](improving-model.md)。
有关其他模型任务（例如标记模型），请参阅[管理 Amazon Rekognition Custom Labels 模型](managing-model.md)。
**Topics**
+ [训练模型（控制台）](#tm-console)
+ [训练模型（SDK）](#tm-sdk)
## 训练模型（控制台）
可以使用 Amazon Rekognition Custom Labels 控制台训练项目。
训练需要一个包含训练数据集和测试数据集的项目。如果项目没有测试数据集，Amazon Rekognition Custom Labels 控制台会在训练期间拆分训练数据集，为项目创建一个测试数据集。所选图像是具有代表性的采样，不会用于训练数据集。建议您仅在没有可供使用的替代测试数据集时才拆分训练数据集。拆分训练数据集会减少可用于训练的图像数量。
**注意**
您需要按照训练模型所花费的时间付费。有关更多信息，请参阅[训练时长](https://aws.amazon.com/rekognition/pricing/#Amazon_Rekognition_Custom_Labels_pricing)。
**训练模型（控制台）**
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 在左侧导航窗格中，选择**项目**。
1. 在**项目**页面上，选择包含要训练的模型的项目。
1. 在**项目**页面上，选择**训练模型**。
![\[“训练模型”按钮用于在当前项目中的数据集上训练机器学习模型。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/tutorial-train-model.jpg)
1. （可选）如果要使用自己的 AWS KMS 加密密钥，请执行以下操作：
1. 在**图像数据加密**中，选择**自定义加密设置(高级)**。
1. 在 **encryption.aws\$1kms\$1key** 中，输入您的密钥的 Amazon 资源名称 (ARN)，或者选择现有的 AWS KMS 密钥。要创建新密钥，请选择**创建 AWS IMS 密钥**。
1. （可选）如果要向模型添加标签，请执行以下操作：
1. 在**标签**部分，选择**添加新标签**。
1. 输入以下信息：
1. 在**键**中输入键名称。
1. 在**值**中输入键值。
1. 要添加更多标签，请重复步骤 6a 和 6b。
1. （可选）如果要移除标签，请选择要移除的标签旁的**移除**。如果移除的是先前保存的标签，则会在保存更改时将其移除。
1. 在**训练模型**页面上，选择**训练模型**。项目的 Amazon 资源名称 (ARN) 应位于**选择项目**编辑框中。如果没有，请输入项目的 ARN。
![\[单击“训练模型”按钮可开始在 Amazon Rekognition Custom Labels 服务上训练人工智能模型。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/tutorial-train-model-page-train-model.jpg)
1. 在**是否要训练您的模型？**对话框中，选择**训练模型**。
![\[训练模型配置页面显示“训练模型”按钮。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/tutorial-dialog-train-model.jpg)
1. 在项目页面的**模型**部分，可以在 `Model Status` 列中查看当前状态，状态显示训练正在进行。训练模型需要一些时间才能完成。
![\[模型状态显示“TRAINING_IN_PROGRESS”，表示当前正在训练该模型。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/tutorial-training-progress.jpg)
1. 训练完成后，选择模型名称。当模型状态为 **TRAINING\$1COMPLETED** 时，训练即告完成。如果训练失败，请参阅[调试失败的模型训练](tm-debugging.md)。
![\[界面显示一个经过训练的模型和状态 TRAINING_COMPLETED，表示该模型已准备就绪，随时可以运行。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/get-started-choose-model.jpg)
1. 下一步：评估您的模型。有关更多信息，请参阅 [改进经过训练的 Amazon Rekognition Custom Labels 模型](improving-model.md)。
## 训练模型（SDK）
你可以通过打电话来训练模型[CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)。要训练模型，需要提供以下信息：
+ 名称：模型版本的唯一名称。
+ 项目 ARN：管理模型的项目的 Amazon 资源名称 (ARN)。
+ 训练结果位置：存放结果的 Amazon S3 位置。可以使用与控制台 Amazon S3 存储桶相同的位置，也可以选择其他位置。建议您选择其他位置，因为这样您就可以设置权限，并避免与使用 Amazon Rekognition Custom Labels 控制台时的训练输出发生潜在的命名冲突。
训练使用与项目关联的训练和测试数据集。有关更多信息，请参阅 [管理数据集](managing-dataset.md)。
**注意**
或者，也可以指定项目外部的训练和测试数据集清单文件。如果在使用外部清单文件训练模型后打开控制台，Amazon Rekognition Custom Labels 会使用最后一组用于训练的清单文件为您创建数据集。不能再通过指定外部清单文件来训练项目的模型版本。有关更多信息，请参阅 [CreatePrjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)。
`CreateProjectVersion` 的响应是一个 ARN，用于在后续请求中识别模型版本。您还可以使用 ARN 来保护模型版本。有关更多信息，请参阅 [保护 Amazon Rekognition Custom Labels 项目](sc-introduction.md#sc-resources)。
训练模型版本需要一些时间才能完成。本主题中的 Python 和 Java 示例使用 waiter 来等待训练完成。waiter 是一种实用程序方法，用于轮询是否发生了特定状态。或者，您也可以通过调用 `DescribeProjectVersions` 获取训练的当前状态。当 `Status` 字段的值为 `TRAINING_COMPLETED` 时，即表示训练已完成。训练完成后，您可以通过查看评估结果来评估模型的质量。
### 训练模型 (SDK)
以下示例说明了如何使用与项目关联的训练和测试数据集来训练模型。
**训练模型 (SDK)**
1. 如果您尚未这样做，请安装并配置 AWS CLI 和 AWS SDKs。有关更多信息，请参阅 [步骤 4：设置 AWS CLI 和 AWS SDKs](su-awscli-sdk.md)。
1. 使用以下示例代码来训练项目。
------
#### [ AWS CLI ]
以下示例会创建模型。会拆分训练数据集以创建测试数据集。替换以下内容：
+ 将 `my_project_arn` 替换为项目的 Amazon 资源名称 (ARN)。
+ 将 `version_name` 替换为您选择的唯一版本名称。
+ 将 `output_bucket` 替换为 Amazon Rekognition Custom Labels 保存训练结果的 Amazon S3 存储桶的名称。
+ 将 `output_folder` 替换为保存训练结果的文件夹的名称。
+ （可选参数）将 `--kms-key-id` 替换为您的 AWS Key Management Service 客户主密钥的标识符。
```
aws rekognition create-project-version \
--project-arn project_arn \
--version-name version_name \
--output-config '{"S3Bucket":"output_bucket", "S3KeyPrefix":"output_folder"}' \
--profile custom-labels-access
```
------
#### [ Python ]
以下示例会创建模型。提供以下命令行参数：
+ `project_arn`：项目的 Amazon 资源名称 (ARN)。
+ `version_name`：您选择的模型的唯一版本名称。
+ `output_bucket`：Amazon Rekognition Custom Labels 保存训练结果的 Amazon S3 存储桶的名称。
+ `output_folder`：保存训练结果的文件夹的名称。
或者，提供以下命令行参数以将标签附加到模型：
+ `tag`：您选择的要附加到模型的标签名称。
+ `tag_value`：标签值。
```
#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 json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def train_model(rek_client, project_arn, version_name, output_bucket, output_folder, tag_key, tag_key_value):
"""
Trains an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to train a model.
:param version_name: A version for the model.
:param output_bucket: The S3 bucket that hosts training output.
:param output_folder: The path for the training output within output_bucket
:param tag_key: The name of a tag to attach to the model. Pass None to exclude
:param tag_key_value: The value of the tag. Pass None to exclude
"""
try:
#Train the model
status=""
logger.info("training model version %s for project %s",
version_name, project_arn)
output_config = json.loads(
'{"S3Bucket": "'
+ output_bucket
+ '", "S3KeyPrefix": "'
+ output_folder
+ '" } '
)
tags={}
if tag_key is not None and tag_key_value is not None:
tags = json.loads(
'{"' + tag_key + '":"' + tag_key_value + '"}'
)
response=rek_client.create_project_version(
ProjectArn=project_arn,
VersionName=version_name,
OutputConfig=output_config,
Tags=tags
)
logger.info("Started training: %s", response['ProjectVersionArn'])
# Wait for the project version training to complete.
project_version_training_completed_waiter = rek_client.get_waiter('project_version_training_completed')
project_version_training_completed_waiter.wait(ProjectArn=project_arn,
VersionNames=[version_name])
# Get the completion status.
describe_response=rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in describe_response['ProjectVersionDescriptions']:
logger.info("Status: %s", model['Status'])
logger.info("Message: %s", model['StatusMessage'])
status=model['Status']
logger.info("finished training")
return response['ProjectVersionArn'], status
except ClientError as err:
logger.exception("Couldn't create model: %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 train a model"
)
parser.add_argument(
"version_name", help="A version name of your choosing."
)
parser.add_argument(
"output_bucket", help="The S3 bucket that receives the training results."
)
parser.add_argument(
"output_folder", help="The folder in the S3 bucket where training results are stored."
)
parser.add_argument(
"--tag_name", help="The name of a tag to attach to the model", required=False
)
parser.add_argument(
"--tag_value", help="The value for the tag.", 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()
print(f"Training model version {args.version_name} for project {args.project_arn}")
# Train the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
model_arn, status=train_model(rekognition_client,
args.project_arn,
args.version_name,
args.output_bucket,
args.output_folder,
args.tag_name,
args.tag_value)
print(f"Finished training model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
except Exception as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
以下示例会训练模型。提供以下命令行参数：
+ `project_arn`：项目的 Amazon 资源名称 (ARN)。
+ `version_name`：您选择的模型的唯一版本名称。
+ `output_bucket`：Amazon Rekognition Custom Labels 保存训练结果的 Amazon S3 存储桶的名称。
+ `output_folder`：保存训练结果的文件夹的名称。
```
/*
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.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TrainModel {
public static final Logger logger = Logger.getLogger(TrainModel.class.getName());
public static String trainMyModel(RekognitionClient rekClient, String projectArn, String versionName,
String outputBucket, String outputFolder) {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
logger.log(Level.INFO, "Training Model for project {0}", projectArn);
CreateProjectVersionRequest createProjectVersionRequest = CreateProjectVersionRequest.builder()
.projectArn(projectArn).versionName(versionName).outputConfig(outputConfig).build();
CreateProjectVersionResponse response = rekClient.createProjectVersion(createProjectVersionRequest);
logger.log(Level.INFO, "Model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Training model...");
// wait until training completes
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(projectArn)
.build();
RekognitionWaiter waiter = rekClient.waiter();
WaiterResponse waiterResponse = waiter
.waitUntilProjectVersionTrainingCompleted(describeProjectVersionsRequest);
Optional optionalResponse = waiterResponse.matched().response();
DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
System.out.println("Status: " + projectVersionDescription.statusAsString());
System.out.println("Message: " + projectVersionDescription.statusMessage());
}
return response.projectVersionArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String versionName = null;
String projectArn = null;
String projectVersionArn = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that you want to use. \n\n"
+ " version_name - A version name for the model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
versionName = args[1];
bucket = args[2];
location = args[3];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Train model
projectVersionArn = trainMyModel(rekClient, projectArn, versionName, bucket, location);
System.out.println(String.format("Created model: %s for Project ARN: %s", projectVersionArn, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
1. 如果训练失败，请参阅[调试失败的模型训练](tm-debugging.md)。
# 调试失败的模型训练
在模型训练期间，您可能会遇到错误。Amazon Rekognition 自定义标签会在控制台和来自的响应中报告训练错误。[DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)
错误要么是终止性错误（训练无法继续），要么是非终止性错误（训练可以继续）。对于与训练和测试数据集内容相关的错误，您可以下载验证结果（[清单摘要](tm-debugging-summary.md)以及[训练和测试验证清单](tm-debugging-scope-json-line.md)）。使用验证结果中的错误代码在本节中查找更多信息。本节还提供了清单文件错误（在验证清单文件内容之前发生的终止性错误）的信息。
**注意**
清单是用于存储数据集内容的文件。
可以使用 Amazon Rekognition Custom Labels 控制台修复部分错误。其他错误可能需要您更新训练或测试清单文件。您可能需要进行其他更改，例如 IAM 权限。有关更多信息，请参阅文档中的各个错误。
## 终止性错误
终止性错误会停止模型的训练。终止性训练错误分为 3 类：服务错误、清单文件错误和清单内容错误。
在控制台中，Amazon Rekognition Custom Labels 会在项目页面的**状态消息**列中显示模型的终止性错误。项目管理控制面板显示项目列表，包括名称、版本、创建日期、模型性能以及指示模型状态（例如训练已完成或失败）的状态消息
![\[项目管理控制面板的屏幕截图。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/terminal-errors.png)
如果您使用 AWS 软件开发工具包，则可以通过查看来自[DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)的响应来确定是否发生了终端清单文件错误或终端清单内容错误。在本例中，`Status` 值为 `TRAINING_FAILED`，`StatusMessage` 字段包含错误。
### 服务错误
当 Amazon Rekognition 遇到服务问题且无法继续训练时，就会发生终止性服务错误。例如，Amazon Rekognition Custom Labels 所依赖的另一项服务出现故障。当 *Amazon Rekognition 遇到服务问题*时，Amazon Rekognition Custom Labels 就会在控制台中报告服务错误。如果您使用 AWS SDK，则训练期间发生的服务错误会被[CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)和作为`InternalServerError`异常引发[DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)。
如果发生服务错误，请重试模型训练。如果训练仍然失败，请联系 *[AWS Support](https://aws.amazon.com/premiumsupport/)*，并附上与服务错误一起报告的所有错误信息。
### 终止性清单文件错误列表
清单文件错误是终止性错误，在训练和测试数据集中的文件级或跨多个文件发生。清单文件错误可在验证训练和测试数据集内容之前检测到。清单文件错误会阻止报告[非终止性验证错误](#tm-error-category-non-terminal-errors)。例如，空的训练清单文件会生成*清单文件为空*错误。由于文件为空，因此无法报告任何非终止性 JSON 行验证错误。也不会创建清单摘要。
必须先修复清单文件错误，然后才能训练模型。
下面列出了清单文件错误。
+ [清单文件扩展名或内容无效。](tm-terminal-errors-reference.md#tm-error-message-ERROR_MANIFEST_INACCESSIBLE_OR_UNSUPPORTED_FORMAT)
+ [清单文件为空。](tm-terminal-errors-reference.md#tm-error-message-ERROR_EMPTY_MANIFEST)
+ [清单文件大小超过了支持的最大大小。](tm-terminal-errors-reference.md#tm-error-message-ERROR_MANIFEST_SIZE_TOO_LARGE)
+ [无法写入到输出 S3 存储桶。](tm-terminal-errors-reference.md#tm-error-message-ERROR_CANNOT_WRITE_OUTPUT_S3_BUCKET)
+ [S3 存储桶权限不正确。](tm-terminal-errors-reference.md#tm-error-message-ERROR_INVALID_PERMISSIONS_MANIFEST_S3_BUCKET)
### 终止性清单内容错误列表
清单内容错误是与清单中的内容相关的终止性错误。例如，如果收到错误[清单文件中每个标签包含的带标签图像不足，无法执行自动拆分](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_INSUFFICIENT_IMAGES_PER_LABEL_FOR_AUTOSPLIT)，训练将无法完成，因为训练数据集中没有足够的带标签图像来创建测试数据集。
该错误除了在控制台和 `DescribeProjectVersions` 的响应中报告以外，还与任何其他终止性清单内容错误一起在清单摘要中报告。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。
非终止性 JSON 行错误还会在单独的训练和测试验证结果清单中报告。Amazon Rekognition Custom Labels 发现的非终止性 JSON 行错误不一定与停止训练的清单内容错误有关。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。
必须先修复清单内容错误，然后才能训练模型。
以下是清单内容错误的错误消息。
+ [清单文件包含太多无效行。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_TOO_MANY_INVALID_ROWS_IN_MANIFEST)
+ [清单文件包含来自多个 S3 存储桶的图像。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_IMAGES_IN_MULTIPLE_S3_BUCKETS)
+ [图像 S3 存储桶的拥有者 ID 无效。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_INVALID_IMAGES_S3_BUCKET_OWNER)
+ [清单文件中每个标签包含的带标签图像不足，无法执行自动拆分。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_INSUFFICIENT_IMAGES_PER_LABEL_FOR_AUTOSPLIT)
+ [清单文件包含的标签太少。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_MANIFEST_TOO_FEW_LABELS)
+ [清单文件包含的标签太多。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_MANIFEST_TOO_MANY_LABELS)
+ [训练和测试清单文件之间的标签重叠度小于 \$1\$1%。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_INSUFFICIENT_LABEL_OVERLAP)
+ [清单文件包含的可用标签太少。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_MANIFEST_TOO_FEW_USABLE_LABELS)
+ [训练和测试清单文件之间的可用标签重叠度小于 \$1\$1%。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_INSUFFICIENT_USABLE_LABEL_OVERLAP)
+ [无法从 S3 存储桶复制图像。](tm-debugging-aggregate-errors.md#tm-error-message-ERROR_FAILED_IMAGES_S3_COPY)
## 非终止性 JSON 行验证错误列表
JSON 行验证错误是非终止性错误，不需要 Amazon Rekognition Custom Labels 停止训练模型。
JSON 行验证错误不会显示在控制台中。
在训练和测试数据集中，JSON 行代表单张图像的训练或测试信息。JSON 行中的验证错误（例如图像无效）会在训练和测试验证清单中报告。Amazon Rekognition Custom Labels 会使用清单中的其他有效 JSON 行完成训练。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。有关验证规则的信息，请参阅[清单文件的验证规则](md-create-manifest-file-validation-rules.md)。
**注意**
如果 JSON 行错误太多，训练就会失败。
建议将非终止性 JSON 行错误也一并修复，因为它们可能会在将来引起错误或影响您的模型训练。
Amazon Rekognition Custom Labels 可能会生成以下非终止性 JSON 行验证错误。
+ [缺少 source-ref 键。](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_SOURCE_REF)
+ [source-ref 值的格式无效。](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_SOURCE_REF_FORMAT)
+ [未找到标签属性。](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_LABEL_ATTRIBUTES)
+ [标签属性 \$1\$1 的格式无效。](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_ATTRIBUTE_FORMAT)
+ [标签属性元数据的格式无效。](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_LABEL_ATTRIBUTE_METADATA_FORMAT)
+ [未找到有效的标签属性。](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_VALID_LABEL_ATTRIBUTES)
+ [一个或多个边界框缺少置信度值。](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_BOUNDING_BOX_CONFIDENCE)
+ [类别映射中缺少一个或多个类别 ID。](tm-debugging-json-line-errors.md#tm-error-ERROR_MISSING_CLASS_MAP_ID)
+ [JSON 行的格式无效。](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_JSON_LINE)
+ [图像无效。检查 S3 路径 and/or 图像属性。](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_IMAGE)
+ [边界框具有超出边框的值。](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_BOUNDING_BOX)
+ [边界框的高度和宽度太小。](tm-debugging-json-line-errors.md#tm-error-ERROR_BOUNDING_BOX_TOO_SMALL)
+ [边界框的数量超出了允许的最大数量。](tm-debugging-json-line-errors.md#tm-error-ERROR_TOO_MANY_BOUNDING_BOXES)
+ [未找到有效的注释。](tm-debugging-json-line-errors.md#tm-error-ERROR_NO_VALID_ANNOTATIONS)
# 了解清单摘要
清单摘要包含以下信息。
+ 有关在验证期间发生的[终止性清单内容错误列表](tm-debugging.md#tm-error-category-combined-terminal)的错误信息。
+ 训练和测试数据集中的[非终止性 JSON 行验证错误列表](tm-debugging.md#tm-error-category-non-terminal-errors)的错误位置信息。
+ 错误统计信息，例如在训练和测试数据集中发现的无效 JSON 行总数。
如果没有[终止性清单文件错误列表](tm-debugging.md#tm-error-category-terminal)，则会在训练期间创建清单摘要。要获取清单摘要文件 (*manifest\$1summary.json*) 的位置，请参阅[获取验证结果](tm-debugging-getting-validation-data.md)。
**注意**
清单摘要中不会报告[服务错误](tm-debugging.md#tm-error-category-service)和[清单文件错误](tm-debugging.md#tm-error-category-terminal)。有关更多信息，请参阅 [终止性错误](tm-debugging.md#tm-error-categories-terminal)。
有关特定清单内容错误的信息，请参阅[终止性清单内容错误](tm-debugging-aggregate-errors.md)。
## 清单摘要文件格式
清单文件包含 2 个部分：`statistics` 和 `errors`。
### statistics
`statistics` 包含有关训练和测试数据集中错误的信息。
+ `training`：训练数据集中的统计信息和发现的错误。
+ `testing`：测试数据集中的统计信息和发现的错误。
`errors` 数组中的对象包含清单内容错误的错误代码和错误消息。``
`error_line_indices` 数组包含训练或测试清单中存在错误的每个 JSON 行的行号。有关更多信息，请参阅 [修复训练错误](tm-debugging-fixing-validation-errors.md)。
### 错误
跨越训练和测试数据集的错误。例如，当没有足够的可用标签与训练和测试数据集重叠时，就会发生 [ERROR\$1INSUFFICIENT\$1USABLE\$1LABEL\$1OVERLAP](tm-debugging-aggregate-errors.md#tm-error-ERROR_INSUFFICIENT_USABLE_LABEL_OVERLAP)。
```
{
"statistics": {
"training":
{
"use_case": String, # Possible values are IMAGE_LEVEL_LABELS, OBJECT_LOCALIZATION and NOT_DETERMINED
"total_json_lines": Number, # Total number json lines (images) in the training manifest.
"valid_json_lines": Number, # Total number of JSON Lines (images) that can be used for training.
"invalid_json_lines": Number, # Total number of invalid JSON Lines. They are not used for training.
"ignored_json_lines": Number, # JSON Lines that have a valid schema but have no annotations. The aren't used for training and aren't counted as invalid.
"error_json_line_indices": List[int], # Contains a list of line numbers for JSON line errors in the training dataset.
"errors": [
{
"code": String, # Error code for a training manifest content error.
"message": String # Description for a training manifest content error.
}
]
},
"testing":
{
"use_case": String, # Possible values are IMAGE_LEVEL_LABELS, OBJECT_LOCALIZATION and NOT_DETERMINED
"total_json_lines": Number, # Total number json lines (images) in the manifest.
"valid_json_lines": Number, # Total number of JSON Lines (images) that can be used for testing.
"invalid_json_lines": Number, # Total number of invalid JSON Lines. They are not used for testing.
"ignored_json_lines": Number, # JSON Lines that have a valid schema but have no annotations. They aren't used for testing and aren't counted as invalid.
"error_json_line_indices": List[int], # contains a list of error record line numbers in testing dataset.
"errors": [
{
"code": String, # # Error code for a testing manifest content error.
"message": String # Description for a testing manifest content error.
}
]
}
},
"errors": [
{
"code": String, # # Error code for errors that span the training and testing datasets.
"message": String # Description of the error.
}
]
}
```
## 示例清单摘要
以下示例是显示终止性清单内容错误 ([ERROR\$1TOO\$1MANY\$1INVALID\$1ROWS\$1IN\$1MANIFEST](tm-debugging-aggregate-errors.md#tm-error-ERROR_TOO_MANY_INVALID_ROWS_IN_MANIFEST)) 的一部分清单摘要。`error_json_line_indices` 数组包含相应训练或测试验证清单中非终止性 JSON 行错误的行号。
```
{
"errors": [],
"statistics": {
"training": {
"use_case": "NOT_DETERMINED",
"total_json_lines": 301,
"valid_json_lines": 146,
"invalid_json_lines": 155,
"ignored_json_lines": 0,
"errors": [
{
"code": "ERROR_TOO_MANY_INVALID_ROWS_IN_MANIFEST",
"message": "The manifest file contains too many invalid rows."
}
],
"error_json_line_indices": [
15,
16,
17,
22,
23,
24,
.
.
.
.
300
]
},
"testing": {
"use_case": "NOT_DETERMINED",
"total_json_lines": 15,
"valid_json_lines": 13,
"invalid_json_lines": 2,
"ignored_json_lines": 0,
"errors": [],
"error_json_line_indices": [
13,
15
]
}
}
}
```
# 了解训练和测试验证结果清单
在训练期间，Amazon Rekognition Custom Labels 会创建验证结果清单来保存非终止性 JSON 行错误。验证结果清单是添加了错误信息的训练和测试数据集的副本。训练完成后，您可以访问验证清单。有关更多信息，请参阅 [获取验证结果](tm-debugging-getting-validation-data.md)。Amazon Rekognition Custom Labels 还会创建一份清单摘要，其中包含 JSON 行错误的概要信息，例如错误位置和 JSON 行错误计数。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。
**注意**
只有在没有[终止性清单文件错误列表](tm-debugging.md#tm-error-category-terminal)时，才会创建验证结果（训练和测试验证结果清单和清单摘要）。
清单包含数据集中每张图像的 JSON 行。在验证结果清单中，JSON 行错误信息会添加到发生错误的 JSON 行中。
JSON 行错误是指与单张图像相关的非终止性错误。非终止性验证错误可能会使整个 JSON 行或其中的一部分失效。例如，如果 JSON 行中引用的图像不是 PNG 或 JPG 格式，则会发生 [ERROR\$1INVALID\$1IMAGE](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_IMAGE) 错误并将整个 JSON 行排除在训练之外。继续使用其他有效的 JSON 行进行训练。
在一个 JSON 行中，错误可能意味着该 JSON 行仍可用于训练。例如，如果与标签关联的四个边界框中有一个的左值为负，则仍将使用其他有效的边界框训练模型。系统会返回无效边界框的 JSON 行错误信息 ([ERROR\$1INVALID\$1BOUNDING\$1BOX](tm-debugging-json-line-errors.md#tm-error-ERROR_INVALID_BOUNDING_BOX))。在此示例中，错误信息会被添加到发生错误的 `annotation` 对象。
警告错误（例如 [WARNING\$1NO\$1ANNOTATIONS](tm-debugging-json-line-errors.md#tm-warning-WARNING_NO_ANNOTATIONS)）不会用于训练，并会在清单摘要中计为忽略的 JSON 行 (`ignored_json_lines`)。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。此外，忽略的 JSON 行也不会计入训练和测试的 20% 错误阈值。
有关特定非终止性数据验证错误的信息，请参见[非终止性 JSON 行验证错误](tm-debugging-json-line-errors.md)。
**注意**
如果数据验证错误太多，将会停止训练，并在清单摘要中报告 [ERROR\$1TOO\$1MANY\$1INVALID\$1ROWS\$1IN\$1MANIFEST](tm-debugging-aggregate-errors.md#tm-error-ERROR_TOO_MANY_INVALID_ROWS_IN_MANIFEST)终止性错误。
有关更正 JSON 行错误的信息，请参阅[修复训练错误](tm-debugging-fixing-validation-errors.md)。
## JSON 行错误格式
Amazon Rekognition Custom Labels 会将非终止性验证错误信息添加到图像级和物体定位格式 JSON 行中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
### 图像级错误
以下示例显示了图像级 JSON 行中的 `Error` 数组。有两组错误。与标签属性元数据相关的错误（在本例中为 sport-metadata）以及与图像相关的错误。错误中包含错误代码 (code) 和错误消息 (message)。有关更多信息，请参阅 [在清单文件中导入图像级标签](md-create-manifest-file-classification.md)。
```
{
"source-ref": String,
"sport": Number,
"sport-metadata": {
"class-name": String,
"confidence": Float,
"type": String,
"job-name": String,
"human-annotated": String,
"creation-date": String,
"errors": [
{
"code": String, # error codes for label
"message": String # Description and additional contextual details of the error
}
]
},
"errors": [
{
"code": String, # error codes for image
"message": String # Description and additional contextual details of the error
}
]
}
```
### 物体定位错误
以下示例显示了一个物体定位 JSON 行中的错误数组。该 JSON 行包含以下 JSON 行部分中的字段的 `Errors` 数组信息。每个 `Error` 对象都包含错误代码和错误消息。
+ *label attribute*：标签属性字段的错误。请参阅示例中的 `bounding-box`。
+ *annotations*：注释错误（边界框）存储在标签属性内的 `annotations` 数组中。
+ *label attribute-metadata*：标签属性元数据的错误。请参阅示例中的 `bounding-box-metadata`。
+ *image*：与标签属性、注释和标签属性元数据字段无关的错误。
有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
```
{
"source-ref": String,
"bounding-box": {
"image_size": [
{
"width": Int,
"height": Int,
"depth":Int,
}
],
"annotations": [
{
"class_id": Int,
"left": Int,
"top": Int,
"width": Int,
"height": Int,
"errors": [ # annotation field errors
{
"code": String, # annotation field error code
"message": String # Description and additional contextual details of the error
}
]
}
],
"errors": [ #label attribute field errors
{
"code": String, # error code
"message": String # Description and additional contextual details of the error
}
]
},
"bounding-box-metadata": {
"objects": [
{
"confidence": Float
}
],
"class-map": {
String: String
},
"type": String,
"human-annotated": String,
"creation-date": String,
"job-name": String,
"errors": [ #metadata field errors
{
"code": String, # error code
"message": String # Description and additional contextual details of the error
}
]
},
"errors": [ # image errors
{
"code": String, # error code
"message": String # Description and additional contextual details of the error
}
]
}
```
## JSON 行错误示例
以下物体定位 JSON 行（为便于阅读调整了格式）显示了 [ERROR\$1BOUNDING\$1BOX\$1TOO\$1SMALL](tm-debugging-json-line-errors.md#tm-error-ERROR_BOUNDING_BOX_TOO_SMALL) 错误。在本示例中，边界框尺寸（高度和宽度）不大于 1 x 1。
```
{
"source-ref": "s3://bucket/Manifests/images/199940-1791.jpg",
"bounding-box": {
"image_size": [
{
"width": 3000,
"height": 3000,
"depth": 3
}
],
"annotations": [
{
"class_id": 1,
"top": 0,
"left": 0,
"width": 1,
"height": 1,
"errors": [
{
"code": "ERROR_BOUNDING_BOX_TOO_SMALL",
"message": "The height and width of the bounding box is too small."
}
]
},
{
"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": "2019-11-20T02:57:28.288286",
"job-name": "my job"
}
}
```
# 获取验证结果
验证结果包含[终止性清单内容错误列表](tm-debugging.md#tm-error-category-combined-terminal)和[非终止性 JSON 行验证错误列表](tm-debugging.md#tm-error-category-non-terminal-errors)的错误信息。有三个验证结果文件。
+ *training\$1manifest\$1with\$1validation.json*：添加了 JSON 行错误信息的训练数据集清单文件的副本。
+ *testing\$1manifest\$1with\$1validation.json*：添加了 JSON 行错误信息的测试数据集清单文件的副本。
+ *manifest\$1summary.json*：训练和测试数据集中发现的清单内容错误和 JSON 行错误的摘要。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。
有关训练和测试验证清单内容的信息，请参阅[调试失败的模型训练](tm-debugging.md)。
**注意**
只有在训练期间未发生[终止性清单文件错误列表](tm-debugging.md#tm-error-category-terminal)时，才会创建验证结果。
如果在验证训练和测试清单后出现[服务错误](tm-debugging.md#tm-error-category-service)，则会创建验证结果，但来自的响应[DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)不包括验证结果文件的位置。
训练完成或失败后，您可以使用 Amazon Rekognition 自定义标签控制台下载验证结果，也可以通过调用 API 获取 Amazon S3 存储桶的位置。[DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)
## 获取验证结果（控制台）
如果使用控制台训练模型，则可以从项目的模型列表下载验证结果，如下图所示。“模型”面板显示模型训练和验证结果，并提供用于下载验证结果的选项。
![\[界面显示模型训练和验证结果，并提供用于下载验证结果的选项。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/models-validation-results.jpg)
您也可以从模型的详细信息页面下载验证结果。详细信息页面显示数据集的详细信息，包括状态、训练和测试数据集，并提供关于清单摘要、训练验证清单和测试验证清单的下载链接。
![\[数据集详细信息面板的屏幕截图，面板包含状态、训练和测试数据集的链接以及清单项目的下载链接。\]](http://docs.aws.amazon.com/zh_cn/rekognition/latest/customlabels-dg/images/model-validation-results.jpg)
有关更多信息，请参阅 [训练模型（控制台）](training-model.md#tm-console)。
## 获取验证结果 (SDK)
模型训练完成后，Amazon Rekognition Custom Labels 会将验证结果存储在训练期间指定的 Amazon S3 存储桶中。训练完成后，您可以通过调用 [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)API 获取 S3 存储桶的位置。要训练模型，请参阅[训练模型（SDK）](training-model.md#tm-sdk)。
返回训练数据集 ([TrainingDataResult](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TrainingDataResult)) 和测试数据集 ([TestingDataResult](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TestingDataResult)) 的[ValidationData](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ValidationData)对象。清单摘要将在 `ManifestSummary` 中返回。
获取 Amazon S3 存储桶位置后，即可下载验证结果。有关更多信息，请参阅[如何从 S3 存储桶下载对象？](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/download-objects.html)。您还可以使用 [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/dev/GettingObjectsUsingAPIs.html) 操作。
**获取验证数据 (SDK)**
1. 如果您尚未这样做，请安装并配置 AWS CLI 和 AWS SDKs。有关更多信息，请参阅 [步骤 4：设置 AWS CLI 和 AWS SDKs](su-awscli-sdk.md)。
1. 使用以下示例获取验证结果的位置。
------
#### [ Python ]
将 `project_arn` 替换为模型所属项目的 Amazon 资源名称 (ARN)。有关更多信息，请参阅 [管理 Amazon Rekognition Custom Labels 项目](managing-project.md)。将 `version_name` 替换为模型版本的名称。有关更多信息，请参阅 [训练模型（SDK）](training-model.md#tm-sdk)。
```
import boto3
import io
from io import BytesIO
import sys
import json
def describe_model(project_arn, version_name):
client=boto3.client('rekognition')
response=client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in response['ProjectVersionDescriptions']:
print(json.dumps(model,indent=4,default=str))
def main():
project_arn='project_arn'
version_name='version_name'
describe_model(project_arn, version_name)
if __name__ == "__main__":
main()
```
------
1. 在程序输出中，注意 `TestingDataResult` 和 `TrainingDataResult` 对象中的 `Validation` 字段。清单摘要在 `ManifestSummary` 中。
# 修复训练错误
可以使用清单摘要来识别训练期间发生的[终止性清单内容错误列表](tm-debugging.md#tm-error-category-combined-terminal)和[非终止性 JSON 行验证错误列表](tm-debugging.md#tm-error-category-non-terminal-errors)。必须修复清单内容错误。建议将非终止性 JSON 行错误也一并修复。有关特定错误的信息，请参阅[非终止性 JSON 行验证错误](tm-debugging-json-line-errors.md)和[终止性清单内容错误](tm-debugging-aggregate-errors.md)。
您可以修复用于训练的训练或测试数据集。或者，也可以在训练和测试验证清单文件中进行修复，然后使用它们来训练模型。
修复完毕后，您需要导入更新后的清单并重新训练模型。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
以下过程说明了如何使用清单摘要来修复终止性清单内容错误。该过程还说明了如何定位和修复训练和测试验证清单中的 JSON 行错误。
**修复 Amazon Rekognition Custom Labels 训练错误**
1. 下载验证结果文件。文件名为 *training\$1manifest\$1with\$1validation.json*、*testing\$1manifest\$1with\$1validation.json* 和 *manifest\$1summary.json*。有关更多信息，请参阅 [获取验证结果](tm-debugging-getting-validation-data.md)。
1. 打开清单摘要文件 (*manifest\$1summary.json*)。
1. 修复清单摘要中的所有错误。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。
1. 在清单摘要中，遍历 `training` 中的 `error_line_indices` 数组，并根据相应的 JSON 行号修复 `training_manifest_with_validation.json` 中的错误。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。
1. 遍历 `testing` 中的 `error_line_indices` 数组，并根据相应的 JSON 行号修复 `testing_manifest_with_validation.json` 中的错误。
1. 使用验证清单文件作为训练和测试数据集重新训练模型。有关更多信息，请参阅 [训练 Amazon Rekognition Custom Labels 模型](training-model.md)。
如果您正在使用 AWS 软件开发工具包并选择修复训练或测试验证数据清单文件中的错误，请使用验证数据清单文件在中的位置[TrainingData](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TrainingData)并将参数[TestingData](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TestingData)输入到[CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)。有关更多信息，请参阅 [训练模型（SDK）](training-model.md#tm-sdk)。
## JSON 行错误优先级
会先检测以下 JSON 行错误。如果出现这些错误中的任何一个，则会停止验证 JSON 行错误。必须先修复这些错误，然后才能修复任何其他 JSON 行错误
+ MISSING\$1SOURCE\$1REF
+ ERROR\$1INVALID\$1SOURCE\$1REF\$1FORMAT
+ ERROR\$1NO\$1LABEL\$1ATTRIBUTES
+ ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1FORMAT
+ ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1METADATA\$1FORMAT
+ ERROR\$1MISSING\$1BOUNDING\$1BOX\$1CONFIDENCE
+ ERROR\$1MISSING\$1CLASS\$1MAP\$1ID
+ ERROR\$1INVALID\$1JSON\$1LINE
# 终止性清单文件错误
本主题将介绍[终止性清单文件错误列表](tm-debugging.md#tm-error-category-terminal)。清单文件错误没有相关的错误代码。当发生终止性清单文件错误时，将不会创建验证结果清单。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。终止性清单错误会阻止报告[非终止性 JSON 行验证错误](tm-debugging-json-line-errors.md)。
## 清单文件扩展名或内容无效。
训练或测试清单文件没有文件扩展名或其内容无效。
**修复*清单文件扩展名或内容无效*错误**
+ 在训练和测试清单文件中检查以下可能的原因。
+ 清单文件缺少文件扩展名。按照惯例，文件扩展名为 `.manifest`。
+ 找不到清单文件的 Amazon S3 存储桶或密钥。
## 清单文件为空。
存在用于训练的训练或测试清单文件，但文件是空的。清单文件需要为用于训练和测试的每张图像都提供一个 JSON 行。
**修复*清单文件为空*错误**
1. 检查哪些训练或测试清单是空的。
1. 将 JSON 行添加到空清单文件中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。或者，使用控制台创建新数据集。有关更多信息，请参阅 [使用图像创建训练和测试数据集](md-create-dataset.md)。
## 清单文件大小超过了支持的最大大小。
训练或测试清单文件大小（以字节为单位）太大。有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。清单文件可能会 JSON 行数少于最大值，但文件大小超过最大值。
无法使用 Amazon Rekognition Custom Labels 控制台修复错误：*清单文件大小超过了支持的最大大小*。
**修复*清单文件大小超过了支持的最大大小*错误**
1. 检查哪些训练和测试清单文件超过了最大文件大小。
1. 减少过大的清单文件中的 JSON 行数。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
## S3 存储桶权限不正确。
Amazon Rekognition Custom Labels 不具有对一个或多个包含训练和测试清单文件的存储桶的权限。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复 *S3 存储桶权限不正确*错误**
+ 检查对包含训练和测试清单的存储桶的权限。有关更多信息，请参阅 [步骤 2：设置 Amazon Rekognition Custom Labels 控制台权限](su-console-policy.md)。
## 无法写入到输出 S3 存储桶。
服务无法生成训练输出文件。
**修复*无法写入到输出 S3 存储桶*错误**
+ 检查[OutputConfig](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_OutputConfig)输入参数中的 Amazon S3 存储桶信息是否[CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)正确。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
# 终止性清单内容错误
本主题将介绍清单摘要中报告的[终止性清单内容错误列表](tm-debugging.md#tm-error-category-combined-terminal)。清单摘要中包含检测到的每个错误的错误代码和错误消息。有关更多信息，请参阅 [了解清单摘要](tm-debugging-summary.md)。终止性清单内容错误不会阻止报告[非终止性 JSON 行验证错误列表](tm-debugging.md#tm-error-category-non-terminal-errors)。
## ERROR\$1TOO\$1MANY\$1INVALID\$1ROWS\$1IN\$1MANIFEST
### 错误消息
清单文件包含太多无效行。
### 更多信息
如果包含无效内容的 JSON 行过多，则会发生 `ERROR_TOO_MANY_INVALID_ROWS_IN_MANIFEST` 错误。
无法使用 Amazon Rekognition Custom Labels 控制台修复 `ERROR_TOO_MANY_INVALID_ROWS_IN_MANIFEST` 错误。
**修复 ERROR\$1TOO\$1MANY\$1INVALID\$1ROWS\$1IN\$1MANIFEST**
1. 检查清单中是否包含 JSON 行错误。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。
1. 修复有错误的 JSON 行。有关更多信息，请参阅[非终止性 JSON 行验证错误](tm-debugging-json-line-errors.md)。
## ERROR\$1IMAGES\$1IN\$1MULTIPLE\$1S3\$1BUCKETS
### 错误消息
清单文件包含来自多个 S3 存储桶的图像。
### 更多信息
清单只能引用存储在单个存储桶中的图像。每个 JSON 行都将一张图像位置的 Amazon S3 位置存储在 `source-ref` 的值中。在以下示例中，存储桶名称为 *my-bucket*。
```
"source-ref": "s3://my-bucket/images/sunrise.png"
```
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复 `ERROR_IMAGES_IN_MULTIPLE_S3_BUCKETS`**
+ 确保所有图像都在同一 Amazon S3 存储桶中，并且每个 JSON 行中的 `source-ref` 的值都引用存储图像的存储桶。或者，也可以选择首选的 Amazon S3 存储桶，并删除其 `source-ref` 未引用首选存储桶的 JSON 行。
## ERROR\$1INVALID\$1PERMISSIONS\$1IMAGES\$1S3\$1BUCKET
### 错误消息
对图像 S3 存储桶的权限无效。
### 更多信息
对包含图像的 Amazon S3 存储桶的权限不正确。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复 `ERROR_INVALID_PERMISSIONS_IMAGES_S3_BUCKET`**
+ 检查对包含图像的存储桶的权限。图像的 `source-ref` 的值包含存储桶位置。
## ERROR\$1INVALID\$1IMAGES\$1S3\$1BUCKET\$1OWNER
### 错误消息
图像 S3 存储桶的拥有者 ID 无效。
### 更多信息
包含训练或测试图像的存储桶的拥有者与包含训练或测试清单的存储桶的拥有者不同。可以使用以下命令查找存储桶的拥有者。
```
aws s3api get-bucket-acl --bucket amzn-s3-demo-bucket
```
`OWNER` `ID` 必须与存储图像和清单文件的存储桶相匹配。
**修复 ERROR\$1INVALID\$1IMAGES\$1S3\$1BUCKET\$1OWNER**
1. 选择训练、测试、输出和图像存储桶的所需拥有者。拥有者必须有权使用 Amazon Rekognition Custom Labels。
1. 对于当前未由所需拥有者拥有的每个存储桶，请创建一个由首选拥有者拥有的新 Amazon S3 存储桶。
1. 将旧存储桶中的内容复制到新存储桶。有关更多信息，请参阅[如何在 Amazon S3 存储桶之间复制对象？](https://aws.amazon.com/premiumsupport/knowledge-center/move-objects-s3-bucket/)。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1AUTOSPLIT
### 错误消息
清单文件中每个标签包含的带标签图像不足，无法执行自动拆分。
### 更多信息
在模型训练期间，可以使用训练数据集中 20% 的图像来创建测试数据集。当没有足够的图像来创建可接受的测试数据集时，就会发生 ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1AUTOSPLIT 错误。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复 ERROR\$1INSUFFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1AUTOSPLIT**
+ 向训练数据集中添加更多带标签的图像。可以在 Amazon Rekognition Custom Labels 控制台中添加图像，方法是：向训练数据集添加图像，或者向训练清单中添加 JSON 行。有关更多信息，请参阅 [管理数据集](managing-dataset.md)。
## ERROR\$1MANIFEST\$1TOO\$1FEW\$1LABELS
### 错误消息
清单文件包含的标签太少。
### 更多信息
训练和测试数据集具有最低标签数量要求。最小值取决于数据集 trains/tests 是用于检测图像级标签（分类）的模型，还是模型检测到对象位置。如果拆分训练数据集来创建测试数据集，则数据集中的标签数量将在拆分训练数据集后确定。有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。
**修复 ERROR\$1MANIFEST\$1TOO\$1FEW\$1LABELS（控制台）**
1. 向数据集添加更多新标签。有关更多信息，请参阅 [管理标签](md-labels.md)。
1. 向数据集中的图像添加新标签。如果模型用于检测图像级标签，请参阅[为图像分配图像级标签](md-assign-image-level-labels.md)。如果模型用于检测物体位置，请参阅[使用边界框标注物体](md-localize-objects.md)。
**修复 ERROR\$1MANIFEST\$1TOO\$1FEW\$1LABELS（JSON 行）**
+ 为带有新标签的新图像添加 JSON 行。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。如果模型用于检测图像级标签，则可以在 `class-name` 字段中添加新标签名称。例如，下图的标签是 *Sunrise*。
```
{
"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": "2018-10-18T22:18:13.527256",
"type": "groundtruth/image-classification"
}
}
```
如果模型用于检测物体位置，请添加新标签至 `class-map`，如以下示例所示。
```
{
"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": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
您需要将类别映射表映射到边界框注释。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
## ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS
### 错误消息
清单文件包含的标签太多。
#### 更多信息
清单（数据集）中唯一标签的数量超过了允许的限制。如果拆分训练数据集来创建测试数据集，则标签数量将在拆分后确定。
**修复 ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS（控制台）**
+ 从数据集中移除标签。有关更多信息，请参阅 [管理标签](md-labels.md)。标签会自动从数据集中的图像和边界框中移除。
**修复 ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS（JSON 行）**
+ 清单包含图像级 JSON 行 - 如果图像只有一个标签，请移除使用所需标签的图像对应的 JSON 行。如果相关 JSON 行包含多个标签，请仅移除所需标签对应的 JSON 对象。有关更多信息，请参阅 [为图像添加多个图像级标签](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels)。
清单包含物体位置 JSON 行 - 移除要移除的标签所对应的边界框和关联的标签信息。对包含所需标签的每个 JSON 行执行此操作。需要从 `class-map` 数组中移除标签并从 `objects` 和 `annotations` 数组中移除相应的对象。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
## ERROR\$1INSUFFICIENT\$1LABEL\$1OVERLAP
### 错误消息
训练和测试清单文件之间的标签重叠度小于 \$1\$1%。
### 更多信息
测试数据集标签名称和训练数据集标签名称之间的重叠度小于 50%。
**修复 ERROR\$1INSUFFICIENT\$1LABEL\$1OVERLAP（控制台）**
+ 从训练数据集中移除标签。或者，向测试数据集中添加更多共用标签。有关更多信息，请参阅 [管理标签](md-labels.md)。标签会自动从数据集中的图像和边界框中移除。
**通过从训练数据集中移除标签来修复 ERROR\$1INSUFFICIENT\$1LABEL\$1OVERLAP（JSON 行）**
+ 清单包含图像级 JSON 行：如果图像只有一个标签，请移除使用所需标签的图像对应的 JSON 行。如果相关 JSON 行包含多个标签，请仅移除所需标签对应的 JSON 对象。有关更多信息，请参阅 [为图像添加多个图像级标签](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels)。对清单中每个包含您要移除的标签的 JSON 行执行此操作。
清单包含物体位置 JSON 行 - 移除要移除的标签所对应的边界框和关联的标签信息。对包含所需标签的每个 JSON 行执行此操作。需要从 `class-map` 数组中移除标签并从 `objects` 和 `annotations` 数组中移除相应的对象。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
**通过向测试数据集中添加共用标签来修复 ERROR\$1INSUFFICIENT\$1LABEL\$1OVERLAP（JSON 行）**
+ 向测试数据集中添加 JSON 行，这些行应包含带有训练数据集中已有标签的图像。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
## ERROR\$1MANIFEST\$1TOO\$1FEW\$1USABLE\$1LABELS
### 错误消息
清单文件包含的可用标签太少。
### 更多信息
训练清单可以包含采用图像级标签格式和物体位置格式的 JSON 行。根据在训练清单中找到的 JSON 行的类型，Amazon Rekognition Custom Labels 会选择创建检测图像级标签或检测物体位置的模型。Amazon Rekognition Custom Labels 会过滤掉未采用所选格式的 JSON 行的有效 JSON 记录。当所选模型类型清单中的标签数量不足以训练模型时，就会发生 ERROR\$1MANIFEST\$1TOO\$1FEW\$1USABLE\$1LABELS 错误。
训练检测图像级标签的模型至少需要 1 个标签。训练检测物体位置的模型至少需要 2 个标签。
**修复 ERROR\$1MANIFEST\$1TOO\$1FEW\$1USABLE\$1LABELS（控制台）**
1. 检查清单摘要中的 `use_case` 字段。
1. 针对与 `use_case` 的值匹配的使用场景（图像级或物体定位），向训练数据集中添加更多标签。有关更多信息，请参阅 [管理标签](md-labels.md)。标签会自动从数据集中的图像和边界框中移除。
**修复 ERROR\$1MANIFEST\$1TOO\$1FEW\$1USABLE\$1LABELS（JSON 行）**
1. 检查清单摘要中的 `use_case` 字段。
1. 针对与 `use_case` 的值匹配的使用场景（图像级或物体定位），向训练数据集中添加更多标签。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
## ERROR\$1INSUFFICIENT\$1USABLE\$1LABEL\$1OVERLAP
### 错误消息
训练和测试清单文件之间的可用标签重叠度小于 \$1\$1%。
### 更多信息
训练清单可以包含采用图像级标签格式和物体位置格式的 JSON 行。根据在训练清单中找到的格式，Amazon Rekognition Custom Labels 会选择创建检测图像级标签的模型或检测物体位置的模型。Amazon Rekognition Custom Labels 不会使用未采用所选模型格式的 JSON 行的有效 JSON 记录。当所用的测试标签和训练标签之间的重叠度小于 50% 时，就会出现 ERROR\$1INSUFFICIENT\$1USABLE\$1LABEL\$1OVERLAP 错误。
**修复 ERROR\$1INSUFFICIENT\$1USABLE\$1LABEL\$1OVERLAP（控制台）**
+ 从训练数据集中移除标签。或者，向测试数据集中添加更多共用标签。有关更多信息，请参阅 [管理标签](md-labels.md)。标签会自动从数据集中的图像和边界框中移除。
**通过从训练数据集中移除标签来修复 ERROR\$1INSUFFICIENT\$1USABLE\$1LABEL\$1OVERLAP（JSON 行）**
+ 用于检测图像级标签的数据集：如果图像只有一个标签，请移除使用所需标签的图像对应的 JSON 行。如果相关 JSON 行包含多个标签，请仅移除所需标签对应的 JSON 对象。有关更多信息，请参阅 [为图像添加多个图像级标签](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels)。对清单中每个包含您要移除的标签的 JSON 行执行此操作。
用于检测物体位置的数据集：移除要移除的标签对应的边界框和关联的标签信息。对包含所需标签的每个 JSON 行执行此操作。需要从 `class-map` 数组中移除标签并从 `objects` 和 `annotations` 数组中移除相应的对象。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
**通过向测试数据集中添加共用标签来修复 ERROR\$1INSUFFICIENT\$1USABLE\$1LABEL\$1OVERLAP（JSON 行）**
+ 向测试数据集中添加 JSON 行，这些行应包含带有训练数据集中已有标签的图像。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
## ERROR\$1FAILED\$1IMAGES\$1S3\$1COPY
### 错误消息
无法从 S3 存储桶复制图像。
### 更多信息
服务无法复制数据集中的任何图像。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复 ERROR\$1FAILED\$1IMAGES\$1S3\$1COPY**
1. 检查对图像的权限。
1. 如果您正在使用 AWS KMS，请查看存储桶策略。有关更多信息，请参阅 [解密使用加密的文件 AWS Key Management Service](su-encrypt-bucket.md#su-kms-encryption)。
## 清单文件有太多终止性错误。
有太多存在终止性内容错误的 JSON 行。
**修复 `ERROR_TOO_MANY_RECORDS_IN_ERROR`**
+ 减少有终止性内容错误的 JSON 行（图像）的数量。有关更多信息，请参阅 [终止性清单内容错误](#tm-debugging-aggregate-errors)。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
# 非终止性 JSON 行验证错误
本主题列出了 Amazon Rekognition Custom Labels 在训练期间报告的非终止性 JSON 行验证错误。这些错误会在训练和测试验证清单中报告。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。可以通过更新训练或测试清单文件中的 JSON 行来修复非终止性 JSON 行错误。您也可以从清单中删除相关的 JSON 行，但这样做可能会降低模型的质量。如果非终止性验证错误太多，您可能会发现重新创建清单文件更容易。验证错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。有关修复验证错误的信息，请参阅[修复训练错误](tm-debugging-fixing-validation-errors.md)。有些错误可以使用 Amazon Rekognition Custom Labels 控制台修复。
## ERROR\$1MISSING\$1SOURCE\$1REF
### 错误消息
缺少 source-ref 键。
### 更多信息
JSON 行的 `source-ref` 字段提供图像的 Amazon S3 位置。如果 `source-ref` 键缺失或拼写错误，便会发生此错误。此错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
**修复 `ERROR_MISSING_SOURCE_REF`**
1. 检查 `source-ref` 键是否存在且拼写正确。完整的 `source-ref` 键和值类似如下：`"source-ref": "s3://bucket/path/image"`。
1. 更新 JSON 行中的 `source-ref` 键。或者，从清单文件中删除该 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1INVALID\$1SOURCE\$1REF\$1FORMAT
### 错误消息
source-ref 值的格式无效。
### 更多信息
JSON 行中具有 `source-ref` 键，但 Amazon S3 路径的架构不正确。例如，路径是 `https://....` 而不是 `S3://....`。ERROR\$1INVALID\$1SOURCE\$1REF\$1FORMAT 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
**修复 `ERROR_INVALID_SOURCE_REF_FORMAT`**
1. 检查架构是否为 `"source-ref": "s3://bucket/path/image"`。例如 `"source-ref": "s3://custom-labels-console-us-east-1-1111111111/images/000000242287.jpg"`。
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此 `ERROR_INVALID_SOURCE_REF_FORMAT`。
## ERROR\$1NO\$1LABEL\$1ATTRIBUTES
### 错误消息
未找到标签属性。
### 更多信息
标签属性或标签属性 `-metadata` 键名（或两者）无效或缺失。在以下示例中，每当缺少 `bounding-box` 或 `bounding-box-metadata` 键（或两者）时都会发生 `ERROR_NO_LABEL_ATTRIBUTES`。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
```
{
"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": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
`ERROR_NO_LABEL_ATTRIBUTES` 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
**修复 `ERROR_NO_LABEL_ATTRIBUTES`**
1. 检查标签属性标识符和标签属性标识符 `-metadata` 键是否存在，以及键名称拼写是否正确。
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复 `ERROR_NO_LABEL_ATTRIBUTES`。
## ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1FORMAT
### 错误消息
标签属性 \$1\$1 的格式无效。
### 更多信息
标签属性键的架构缺失或无效。ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1FORMAT 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅[创建清单文件](md-create-manifest-file.md)。
**修复 `ERROR_INVALID_LABEL_ATTRIBUTE_FORMAT`**
1. 检查 JSON 行的标签属性键部分是否正确。在以下物体位置示例中，`image_size` 和 `annotations` 对象必须正确。该标签属性键名为 `bounding-box`。
```
"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
}]
},
```
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1METADATA\$1FORMAT
### 错误消息
标签属性元数据的格式无效。
### 更多信息
标签属性元数据键的架构缺失或无效。ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1METADATA\$1FORMAT 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
**修复 `ERROR_INVALID_LABEL_ATTRIBUTE_FORMAT`**
1. 检查标签属性元数据键的 JSON 行架构是否与以下示例类似。该标签属性元数据键名为 `bounding-box-metadata`。
```
"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"
}
```
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1NO\$1VALID\$1LABEL\$1ATTRIBUTES
### 错误消息
未找到有效的标签属性。
### 更多信息
在 JSON 行中未找到有效的标签属性。Amazon Rekognition Custom Labels 会同时检查标签属性和标签属性标识符。ERROR\$1INVALID\$1LABEL\$1ATTRIBUTE\$1FORMAT 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅[创建清单文件](md-create-manifest-file.md)。
如果 JSON 行不是支持的 SageMaker AI 清单格式，Amazon Rekognition 自定义标签会将 JSON 行标记为无效`ERROR_NO_VALID_LABEL_ATTRIBUTES`并报告错误。目前，Amazon Rekognition Custom Labels 支持分类作业和边界框格式。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
**修复 `ERROR_NO_VALID_LABEL_ATTRIBUTES`**
1. 检查 JSON 行中的标签属性键和标签属性元数据是否正确。
1. 更新或移除清单文件中的相关 JSON 行。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1MISSING\$1BOUNDING\$1BOX\$1CONFIDENCE
### 错误消息
一个或多个边界框缺少置信度值。
### 更多信息
一个或多个物体位置边界框缺少 confidence 键。边界框的 confidence 键位于标签属性元数据中，如以下示例中所示。ERROR\$1MISSING\$1BOUNDING\$1BOX\$1CONFIDENCE 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
```
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
```
**修复 `ERROR_MISSING_BOUNDING_BOX_CONFIDENCE`**
1. 检查标签属性中的 `objects` 数组包含的 confidence 键数量是否与标签属性 `annotations` 数组中的对象数量相同。
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1MISSING\$1CLASS\$1MAP\$1ID
### 错误消息
类别映射中缺少一个或多个类别 ID。
### 更多信息
注释（边界框）对象中的 `class_id` 在标签属性元数据类别映射 (`class-map`) 中没有匹配的条目。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。ERROR\$1MISSING\$1CLASS\$1MAP\$1ID 错误通常发生在手动创建的清单文件中。
**修复 ERROR\$1MISSING\$1CLASS\$1MAP\$1ID**
1. 检查每个注释（边界框）对象中的 `class_id` 值在 `class-map` 数组中是否具有对应的值，如以下示例中所示。`annotations` 数组和 `class_map` 数组具有的元素数量应该相同。
```
{
"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": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1INVALID\$1JSON\$1LINE
### 错误消息
JSON 行的格式无效。
### 更多信息
在 JSON 行中发现了意外字符。JSON 行被替换成了仅包含错误信息的新 JSON 行。ERROR\$1INVALID\$1JSON\$1LINE 错误通常发生在手动创建的清单文件中。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
**修复 `ERROR_INVALID_JSON_LINE`**
1. 打开清单文件并导航到发生 ERROR\$1INVALID\$1JSON\$1LINE 错误的 JSON 行。
1. 检查该 JSON 行是否包含无效字符，以及是否缺少必要的 `;` 或 `,` 字符。
1. 更新或移除清单文件中的相关 JSON 行。
## ERROR\$1INVALID\$1IMAGE
### 错误消息
图像无效。检查 S3 路径 and/or 图像属性。
### 更多信息
`source-ref` 引用的文件不是有效的图像。可能的原因包括图像的宽高比、图像大小和图像格式。
有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。
**修复 `ERROR_INVALID_IMAGE`**
1. 检查以下事项。
+ 图像的宽高比是否小于 20:1。
+ 图像大小是否大于 15 MB。
+ 图像是否为 PNG 或 JPEG 格式。
+ `source-ref` 中的图像路径是否正确。
+ 图像的最小图像尺寸是否大于 64 像素 x 64 像素。
+ 图像的最大图像尺寸是否大于 4096 像素 x 4096 像素。
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1INVALID\$1IMAGE\$1DIMENSION
### 错误消息
图像尺寸不符合允许的尺寸。
### 更多信息
`source-ref` 引用的图像不符合允许的图像尺寸。最小尺寸为 64 像素。最大尺寸为 4096 像素。会针对带边界框的图像报告 `ERROR_INVALID_IMAGE_DIMENSION`。
有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。
**修复 `ERROR_INVALID_IMAGE_DIMENSION`（控制台）**
1. 使用 Amazon Rekognition Custom Labels 能够处理的尺寸更新 Amazon S3 存储桶中的图像。
1. 在 Amazon Rekognition Custom Labels 控制台中，执行以下操作：
1. 从图像中移除现有的边界框。
1. 将边界框重新添加到图像中。
1. 保存更改。
有关更多信息，请参阅 [使用边界框标注物体](md-localize-objects.md)。
**修复 `ERROR_INVALID_IMAGE_DIMENSION` (SDK)**
1. 使用 Amazon Rekognition Custom Labels 能够处理的尺寸更新 Amazon S3 存储桶中的图像。
1. 通过调用获取图像的现有 JSON 行[ListDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListDatasetEntries)。对于 `SourceRefContains` 输入参数，请指定图像的 Amazon S3 位置和文件名。
1. 调用[UpdateDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UpdateDatasetEntries)并提供图像的 JSON 行。确保 `source-ref` 的值与 Amazon S3 存储桶中的图像位置匹配。更新边界框注释，使其与更新后的图像所需的边界框尺寸相匹配。
```
{
"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"
}
}
```
## ERROR\$1INVALID\$1BOUNDING\$1BOX
### 错误消息
边界框具有超出边框的值。
### 更多信息
边界框信息指定的图像要么不在图像边框内，要么包含负值。
有关更多信息，请参阅 [Amazon Rekognition Custom Labels 中的准则和配额](limits.md)。
**修复 `ERROR_INVALID_BOUNDING_BOX`**
1. 检查 `annotations` 数组中边界框的值。
```
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [{
"class_id": 1,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}]
},
```
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1NO\$1VALID\$1ANNOTATIONS
### 错误消息
未找到有效的注释。
### 更多信息
JSON 行中的所有注释对象均不包含有效的边界框信息。
**修复 `ERROR_NO_VALID_ANNOTATIONS`**
1. 更新 `annotations` 数组以包含有效的边界框对象。此外，请检查标签属性元数据中的相应边界框信息（`confidence` 和 `class_map`）是否正确。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
```
{
"source-ref": "s3://custom-labels-bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [
{
"class_id": 1, #annotation object
"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 object
},
{
"confidence": 1
}],
"class-map": {
"0": "Echo", #label
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
1. 更新或移除清单文件中的相关 JSON 行。
无法使用 Amazon Rekognition Custom Labels 控制台修复此错误。
## ERROR\$1BOUNDING\$1BOX\$1TOO\$1SMALL
### 错误消息
边界框的高度和宽度太小。
### 更多信息
边界框尺寸（高度和宽度）必须大于 1 x 1 像素。
在训练过程中，如果图像的任何尺寸大于 1280 像素，Amazon Rekognition Custom Labels 就会调整图像的大小（源图像不受影响）。生成的边界框高度和宽度必须大于 1 x 1 像素。边界框位置存储在物体位置 JSON 行的 `annotations` 数组中。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
```
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [{
"class_id": 1,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}]
},
```
错误信息会被添加到注释对象中。
**修复 ERROR\$1BOUNDING\$1BOX\$1TOO\$1SMALL**
+ 选择以下任一选项。
+ 增大太小的边界框的大小。
+ 移除太小的边界框。有关移除边界框的信息，请参阅[ERROR\$1TOO\$1MANY\$1BOUNDING\$1BOXES](#tm-error-ERROR_TOO_MANY_BOUNDING_BOXES)。
+ 从清单中移除图像（JSON 行）。
## ERROR\$1TOO\$1MANY\$1BOUNDING\$1BOXES
### 错误消息
边界框的数量超出了允许的最大数量。
### 更多信息
边界框的数量超出了允许的最大数量 (50)。您可以在 Amazon Rekognition Custom Labels 控制台中移除多余的边界框，也可从 JSON 行中将其移除。
**修复 `ERROR_TOO_MANY_BOUNDING_BOXES`（控制台）。**
1. 决定要移除哪些边界框。
1. 打开亚马逊 Rekognition 控制台，网址为[https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)。
1. 选择**使用自定义标签**。
1. 选择**开始**。
1. 在左侧导航窗格中，选择包含要使用的数据集的项目。
1. 在**数据集**部分中，选择要使用的数据集。
1. 在数据集库页面中，选择**开始标注**进入标注模式。
1. 选择要从中移除边界框的图像。
1. 选择**绘制边界框**。
1. 在绘图工具中，选择要删除的边界框。
1. 按键盘上的删除键即可删除边界框。
1. 重复前面的 2 个步骤，直到删除了足够的边界框。
1. 选择**完成**。
1. 选择**保存更改**以保存您的更改。
1. 选择**退出**，退出标注模式。
**修复 ERROR\$1TOO\$1MANY\$1BOUNDING\$1BOXES（JSON 行）。**
1. 打开清单文件并导航到发生 ERROR\$1TOO\$1MANY\$1BOUNDING\$1BOXES 错误的 JSON 行。
1. 对于要移除的每个边界框，移除以下内容。
+ 从 `annotations` 数组中移除所需的 `annotation` 对象。
+ 从标签属性元数据中的 `objects` 数组中移除相应的 `confidence` 对象。
+ 如果该标签不再被其他边界框使用，请从 `class-map` 中将其移除。
使用以下示例来确定要移除的项目。
```
{
"source-ref": "s3://custom-labels-bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [
{
"class_id": 1, #annotation object
"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 object
},
{
"confidence": 1
}],
"class-map": {
"0": "Echo", #label
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
## WARNING\$1UNANNOTATED\$1RECORD
### 警告消息
记录未添加注释。
### 更多信息
使用 Amazon Rekognition Custom Labels 控制台添加到数据集的图像未添加标签。图像对应的 JSON 行不会用于训练。
```
{
"source-ref": "s3://bucket/images/IMG_1186.png",
"warnings": [
{
"code": "WARNING_UNANNOTATED_RECORD",
"message": "Record is unannotated."
}
]
}
```
**修复 WARNING\$1UNANNOTATED\$1RECORD**
+ 使用 Amazon Rekognition Custom Labels 控制台为图像添加标签。有关说明，请参阅[为图像分配图像级标签](md-assign-image-level-labels.md)。
## WARNING\$1NO\$1ANNOTATIONS
### 警告消息
未提供注释。
### 更多信息
尽管由人工 (`human-annotated = yes`) 注释，但物体定位格式的 JSON 行不包含任何边界框信息。该 JSON 行有效，但不会用于训练。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。
```
{
"source-ref": "s3://bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [
{
"width": 640,
"height": 480,
"depth": 3
}
],
"annotations": [
],
"warnings": [
{
"code": "WARNING_NO_ATTRIBUTE_ANNOTATIONS",
"message": "No attribute annotations were found."
}
]
},
"bounding-box-metadata": {
"objects": [
],
"class-map": {
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2013-11-18 02:53:27",
"job-name": "my job"
},
"warnings": [
{
"code": "WARNING_NO_ANNOTATIONS",
"message": "No annotations were found."
}
]
}
```
**修复 WARNING\$1NO\$1ANNOTATIONS**
+ 选择以下任一选项。
+ 将边界框 (`annotations`) 信息添加到 JSON 行。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
+ 从清单中移除图像（JSON 行）。
## WARNING\$1NO\$1ATTRIBUTE\$1ANNOTATIONS
### 警告消息
未提供属性注释。
#### 更多信息
尽管由人工 (`human-annotated = yes`) 注释，但物体定位格式的 JSON 行不包含任何边界框注释信息。`annotations` 数组不存在或未填充。该 JSON 行有效，但不会用于训练。有关更多信息，请参阅 [了解训练和测试验证结果清单](tm-debugging-scope-json-line.md)。
```
{
"source-ref": "s3://bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [
{
"width": 640,
"height": 480,
"depth": 3
}
],
"annotations": [
],
"warnings": [
{
"code": "WARNING_NO_ATTRIBUTE_ANNOTATIONS",
"message": "No attribute annotations were found."
}
]
},
"bounding-box-metadata": {
"objects": [
],
"class-map": {
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2013-11-18 02:53:27",
"job-name": "my job"
},
"warnings": [
{
"code": "WARNING_NO_ANNOTATIONS",
"message": "No annotations were found."
}
]
}
```
**修复 WARNING\$1NO\$1ATTRIBUTE\$1ANNOTATIONS**
+ 选择以下任一选项。
+ 将一个或多个边界框 `annotation` 对象添加到 JSON 行。有关更多信息，请参阅 [清单文件中的物体定位](md-create-manifest-file-object-detection.md)。
+ 移除边界框属性。
+ 从清单中移除图像（JSON 行）。如果 JSON 行中存在其他有效的边界框属性，则可以仅从 JSON 行中移除无效的边界框属性。
## ERROR\$1UNSUPPORTED\$1USE\$1CASE\$1TYPE
### 警告消息
### 更多信息
`type ` 字段的值不是 `groundtruth/image-classification` 或 `groundtruth/object-detection`。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
```
{
"source-ref": "s3://bucket/test_normal_8.jpg",
"BB": {
"annotations": [
{
"left": 1768,
"top": 1007,
"width": 448,
"height": 295,
"class_id": 0
},
{
"left": 1794,
"top": 1306,
"width": 432,
"height": 411,
"class_id": 1
},
{
"left": 2568,
"top": 1346,
"width": 710,
"height": 305,
"class_id": 2
},
{
"left": 2571,
"top": 1020,
"width": 644,
"height": 312,
"class_id": 3
}
],
"image_size": [
{
"width": 4000,
"height": 2667,
"depth": 3
}
]
},
"BB-metadata": {
"job-name": "labeling-job/BB",
"class-map": {
"0": "comparator",
"1": "pot_resistor",
"2": "ir_phototransistor",
"3": "ir_led"
},
"human-annotated": "yes",
"objects": [
{
"confidence": 1
},
{
"confidence": 1
},
{
"confidence": 1
},
{
"confidence": 1
}
],
"creation-date": "2021-06-22T09:58:34.811Z",
"type": "groundtruth/wrongtype",
"cl-errors": [
{
"code": "ERROR_UNSUPPORTED_USE_CASE_TYPE",
"message": "The use case type of the BB-metadata label attribute metadata is unsupported. Check the type field."
}
]
},
"cl-metadata": {
"is_labeled": true
},
"cl-errors": [
{
"code": "ERROR_NO_VALID_LABEL_ATTRIBUTES",
"message": "No valid label attributes found."
}
]
}
```
**修复 ERROR\$1UNSUPPORTED\$1USE\$1CASE\$1TYPE**
+ 请选择以下选项之一：
+ 根据要创建的模型类型，将 `type` 字段的值更改为 `groundtruth/image-classification` 或 `groundtruth/object-detection`。有关更多信息，请参阅 [创建清单文件](md-create-manifest-file.md)。
+ 从清单中移除图像（JSON 行）。
## ERROR\$1INVALID\$1LABEL\$1NAME\$1LENGTH
### 更多信息
标签名称的长度太长。最大长度为 256 个字符。
**修复 ERROR\$1INVALID\$1LABEL\$1NAME\$1LENGTH**
+ 请选择以下选项之一：
+ 将标签名称的长度减少到 256 个字符以内。
+ 从清单中移除图像（JSON 行）。