本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # 创建训练和测试数据集 数据集是由图像和描述这些图像的标签组成的集合。项目需要一个训练数据集和一个测试数据集。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)