Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Creación de conjuntos de datos de entrenamiento y prueba
Un conjunto de datos es un conjunto de imágenes y etiquetas que describen esas imágenes. El proyecto necesita un conjunto de datos de entrenamiento y un conjunto de datos de prueba. Etiquetas personalizadas de Amazon Rekognition utiliza el conjunto de datos de entrenamiento para entrenar un modelo. Tras el entrenamiento, Etiquetas personalizadas de Amazon Rekognition utiliza el conjunto de datos de prueba para comprobar en qué medida el modelo entrenado predice las etiquetas correctas.
Puede crear conjuntos de datos con la consola Amazon Rekognition Custom Labels o con el SDK. AWS Antes de crear un conjunto de datos, le recomendamos que lea [Qué es Etiquetas personalizadas de Amazon Rekognition](understanding-custom-labels.md). En el caso de otras tareas relacionadas con los conjuntos de datos, consulte [Administración de conjuntos de datos](managing-dataset.md).
Los pasos para crear conjuntos de datos de entrenamiento y prueba para un proyecto son los siguientes:
**Cómo crear conjuntos de datos de entrenamiento y prueba para su proyecto**
1. Determine cómo debe etiquetar sus conjuntos de datos de entrenamiento y prueba. Para obtener más información, [Finalidad de los conjuntos de datos](md-dataset-purpose.md).
1. Recopile las imágenes para sus conjuntos de datos de entrenamiento y prueba. Para obtener más información, consulte [Preparación de imágenes](md-prepare-images.md).
1. Cree los conjuntos de datos de entrenamiento y de prueba. Para obtener más información, consulte [Creación de conjuntos de datos de entrenamiento y prueba](md-create-dataset.md). Si utiliza el SDK, consulte. AWS [Crear conjuntos de datos de entrenamiento y prueba (SDK)](md-create-dataset.md#cd-create-dataset-sdk)
1. Si es necesario, agregue etiquetas de tipo imagen o cuadros delimitadores a las imágenes de su conjunto de datos. Para obtener más información, consulte [Etiquetado de imágenes](md-labeling-images.md).
Después de crear los conjuntos de datos, puede [entrenar](training-model.md) el modelo.
**Topics**
+ [Finalidad de los conjuntos de datos](md-dataset-purpose.md)
+ [Preparación de imágenes](md-prepare-images.md)
+ [Creación de conjuntos de datos de entrenamiento y prueba](md-create-dataset.md)
+ [Etiquetado de imágenes](md-labeling-images.md)
+ [Depuración de errores de conjuntos de datos](debugging-datasets.md)
# Finalidad de los conjuntos de datos
La forma en que etiquete los conjuntos de datos de entrenamiento y prueba de su proyecto determina el tipo de modelo que se va a crear. Con Etiquetas personalizadas de Amazon Rekognition, puede crear modelos que hagan lo siguiente.
+ [Encontrar objetos, escenas y conceptos](#md-dataset-purpose-classification)
+ [Encontrar ubicaciones de objetos](#md-dataset-purpose-localization)
+ [Encontrar ubicaciones de marcas](#md-dataset-purpose-brands)
## Encontrar objetos, escenas y conceptos
El modelo clasifica los objetos, las escenas y los conceptos que están asociados a una imagen completa.
Puede crear dos tipos de modelo de clasificación: *clasificación de imágenes* y *clasificación de etiquetas múltiples*. Para ambos tipos de modelo de clasificación, el modelo busca una o varias etiquetas que coincidan del conjunto entero de etiquetas utilizado para realizar el entrenamiento. Tanto los conjuntos de datos de entrenamiento como los de prueba necesitan al menos dos etiquetas.
### Clasificación de imágenes
El modelo clasifica las imágenes como pertenecientes a un conjunto de etiquetas predefinidas. Por ejemplo, si desea un modelo que determine si en la imagen hay una sala de estar. La siguiente imagen puede tener una etiqueta de imagen *sala\$1estar*.
![\[Acogedora sala de estar con chimenea y grandes ventanales con vistas al patio trasero. Tonos neutros, detalles en madera.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/living_space1.jpeg)
Para este tipo de modelo, agregue una sola etiqueta de imagen a cada una de las imágenes del conjunto de datos de entrenamiento y prueba. Para ver un objeto de ejemplo, consulte [Clasificación de imágenes](getting-started.md#gs-image-classification-example).
### Clasificación de etiquetas múltiples
El modelo clasifica las imágenes en varias categorías, como por ejemplo, el tipo de flor y si tiene hojas o no. Por ejemplo, la imagen siguiente puede tener las etiquetas de imagen *euforbio\$1mediterráneo* y *sin\$1hojas*.
![\[Primer plano de un racimo de flores de viburnum de color verde con pequeños capullos cerrados.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/mediterranean_spurge3.jpg)
Para este tipo de modelo, asigne etiquetas de imagen por cada categoría a las imágenes del conjunto de datos de entrenamiento y prueba. Para ver un objeto de ejemplo, consulte [Clasificación de imágenes de etiquetas múltiples](getting-started.md#gs-multi-label-image-classification-example).
### Asignación de etiquetas de imagen
Si las imágenes están almacenadas en un bucket de Amazon S3, puede utilizar los [nombres de las carpetas](md-create-dataset-s3.md) para agregar automáticamente etiquetas de imagen. Para obtener más información, consulte [Importar imágenes desde un bucket de Amazon S3](md-create-dataset-s3.md). También puede agregar etiquetas de imagen a las imágenes después de crear un conjunto de datos. Para obtener más información, consulte [Asignación de etiquetas de imagen a una imagen](md-assign-image-level-labels.md). Puede agregar etiquetas nuevas cada vez que las necesite. Para obtener más información, consulte [Administración de etiquetas](md-labels.md).
## Encontrar ubicaciones de objetos
Para crear un modelo que prediga la ubicación de los objetos en las imágenes, defina los cuadros delimitadores de la ubicación de los objetos y las etiquetas para las imágenes en los conjuntos de datos de entrenamiento y prueba. Un cuadro delimitador es un cuadro que rodea ajustadamente un objeto. Por ejemplo, en la siguiente imagen se ven unos cuadros delimitadores alrededor de un Amazon Echo y un Amazon Echo Dot. Cada cuadro delimitador tiene una etiqueta asignada (*Amazon Echo* o *Amazon Echo Dot*).
![\[Dos altavoces inteligentes Amazon, uno con cuadro delimitador verde y otro con cuadro delimitador azul, sobre una superficie de madera.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/echos.png)
Para encontrar las ubicaciones de los objetos, los conjuntos de datos necesitan al menos una etiqueta. Mientras se entrena el modelo, se crea automáticamente otra etiqueta que representa el área situada fuera de los cuadros delimitadores de una imagen.
### Asignación de cuadros delimitadores
Al crear el conjunto de datos, puede incluir información sobre los cuadros delimitadores de las imágenes. Por ejemplo, puedes importar un [archivo de manifiesto](md-create-manifest-file.md) en formato SageMaker AI Ground Truth que contenga cuadros delimitadores. También puede agregar cuadros delimitadores después de crear un conjunto de datos. Para obtener más información, consulte [Etiquetado de objetos con cuadros delimitadores](md-localize-objects.md). Puede agregar etiquetas nuevas cada vez que las necesite. Para obtener más información, consulte [Administración de etiquetas](md-labels.md).
## Encontrar ubicaciones de marcas
Si quiere encontrar la ubicación de marcas, como logotipos y personajes animados, puede usar dos tipos diferentes de imágenes para las imágenes del conjunto de datos de entrenamiento.
+ Imágenes que son solo de logotipo. Cada imagen necesita una única etiqueta de imagen que represente el nombre del logotipo. Por ejemplo, la etiqueta de imagen de la siguiente imagen podría ser *Lambda*.
![\[Logotipo de Lambda en blanco sobre fondo naranja.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/lambda-logo.jpg)
+ Imágenes con el logotipo en ubicaciones naturales, como un partido de fútbol o un diagrama arquitectónico. Cada imagen de entrenamiento necesita cuadros delimitadores que rodeen cada instancia del logotipo. Por ejemplo, en la siguiente imagen se muestra un diagrama de arquitectura con recuadros delimitadores etiquetados que rodean los logotipos de AWS Lambda y Amazon Pinpoint.
![\[Diagrama del flujo de trabajo en el que se muestra el servicio AWS Lambda introduciendo la actividad de los usuarios en Amazon Pinpoint para obtener recomendaciones.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/brand-detection-lambda.png)
Le recomendamos que no mezcle etiquetas de imagen y cuadros delimitadores en las imágenes de entrenamiento.
Las imágenes de prueba deben tener cuadros delimitadores alrededor de las imágenes de la marca que quiera encontrar. Puede dividir el conjunto de datos de entrenamiento para crear el conjunto de datos de prueba, solo si las imágenes de entrenamiento incluyen cuadros delimitadores etiquetados. Si las imágenes de entrenamiento solo tienen etiquetas de imagen, debe crear un conjunto de conjuntos de datos de prueba que incluya imágenes con cuadros delimitadores etiquetados. Si se entrena un modelo para que busque ubicaciones de marcas, haga [Etiquetado de objetos con cuadros delimitadores](md-localize-objects.md) y [Asignación de etiquetas de imagen a una imagen](md-assign-image-level-labels.md) según la forma en que etiquete las imágenes.
En el proyecto de ejemplo [Detección de marcas](getting-started.md#gs-brand-detection-example), se ve cómo Etiquetas personalizadas de Amazon Rekognition utiliza cuadros delimitadores etiquetados para entrenar un modelo que busca ubicaciones de objetos.
## Requisitos de etiquetado de tipos de modelos
Use la siguiente tabla para determinar cómo etiquetar las imágenes.
Puede combinar etiquetas de imagen e imágenes etiquetadas con cuadros delimitadores en un único conjunto de datos. En este caso, Etiquetas personalizadas de Amazon Rekognition elige si desea crear un modelo de imagen o un modelo de ubicación de objetos.
| Ejemplo | Imágenes de entrenamiento | Imágenes de prueba |
| --- | --- | --- |
| [Clasificación de imágenes](#md-dataset-image-classification) | 1 etiqueta de imagen por imagen | 1 etiqueta de imagen por imagen |
| [Clasificación de etiquetas múltiples](#md-dataset-image-classification-multi-label) | Etiquetas múltiples de imagen por imagen | Etiquetas múltiples de imagen por imagen |
| [Encontrar ubicaciones de marcas](#md-dataset-purpose-brands) | Etiquetas de imagen (también puede utilizar cuadros delimitadores etiquetados) | Cuadros delimitadores etiquetados |
| [Encontrar ubicaciones de objetos](#md-dataset-purpose-localization) | Cuadros delimitadores etiquetados | Cuadros delimitadores etiquetados |
# Preparación de imágenes
Las imágenes del conjunto de datos de entrenamiento y prueba contienen los objetos, escenas o conceptos que desea que encuentre el modelo.
El contenido de las imágenes debe estar formado por diversos fondos e iluminación que representen las imágenes que desea que identifique el modelo entrenado.
En esta sección, se da información acerca de las imágenes del conjunto de datos de entrenamiento y prueba.
## Formato de imagen
Puede entrenar los modelos de Etiquetas personalizadas de Amazon Rekognition con imágenes en formato PNG y JPEG. Del mismo modo, para detectar el uso de etiquetas personalizadas con `DetectCustomLabels`, necesitará imágenes en formato PNG y JPEG.
## Recomendaciones de imágenes de entrada
Etiquetas personalizadas de Amazon Rekognition necesita imágenes para entrenar y probar el modelo. Para preparar las imágenes, tenga presente lo siguiente:
+ Elija un dominio específico para el modelo que desee crear. Por ejemplo, puede elegir un modelo con vistas panorámicas y otro modelo con objetos, como piezas de máquinas. Etiquetas personalizadas de Amazon Rekognition funciona mejor si las imágenes se encuentran en el dominio elegido.
+ Utilice al menos 10 imágenes para entrenar el modelo.
+ Las imágenes deben estar en formato PNG o JPEG.
+ Utilice imágenes que muestren el objeto en diferentes iluminaciones, fondos y resoluciones.
+ Las imágenes de entrenamiento y de prueba deben ser similares a las imágenes con las que desea utilizar el modelo.
+ Decida qué etiquetas desea asignar a las imágenes.
+ Asegúrese de que las imágenes sean lo suficientemente grandes en cuanto a resolución. Para obtener más información, consulte [Directrices y cuotas en Etiquetas personalizadas de Amazon Rekognition](limits.md).
+ Asegúrese de que las oclusiones no oculten los objetos que desee detectar.
+ Utilice imágenes que tengan un contraste suficiente respecto al fondo.
+ Utilice imágenes que sean brillantes y nítidas. Evite en la medida de lo posible utilizar imágenes que puedan resultar borrosas debido al movimiento del sujeto y de la cámara.
+ Utilice una imagen en la que el objeto ocupe una gran proporción de la imagen.
+ Las imágenes del conjunto de datos de prueba no deberían ser imágenes del conjunto de datos de entrenamiento. Deben incluir los objetos, las escenas y los conceptos para los que el modelo está entrenado para analizar.
## Tamaño del conjunto de imágenes
Etiquetas personalizadas de Amazon Rekognition utiliza un conjunto de imágenes para entrenar un modelo. Como mínimo, debe utilizar 10 imágenes para el entrenamiento. Etiquetas personalizadas de Amazon Rekognition necesita imágenes para entrenar y probar el modelo. Para obtener más información, consulte [Creación de conjuntos de datos de entrenamiento y prueba](md-create-dataset.md).
# Creación de conjuntos de datos de entrenamiento y prueba
Puede empezar con un proyecto que tenga un único conjunto de datos o un proyecto que tenga conjuntos de datos de entrenamiento y de prueba independientes. Si empieza con un único conjunto de datos, Etiquetas personalizadas de Amazon Rekognition lo divide durante el entrenamiento para crear un conjunto de datos de entrenamiento (80 %) y un conjunto de datos de prueba (20 %) para su proyecto. Comience con un único conjunto de datos si quiere que Etiquetas personalizadas de Amazon Rekognition decida dónde se utilizan las imágenes para el entrenamiento y las pruebas. Para tener un control total sobre el entrenamiento, las pruebas y el nivel de rendimiento, le recomendamos que inicie el proyecto con conjuntos de datos de entrenamiento y prueba independientes.
Puede crear conjuntos de datos de entrenamiento y prueba para un proyecto importando imágenes a través de una de las siguientes ubicaciones:
+ [Importar imágenes desde un bucket de Amazon S3](md-create-dataset-s3.md)
+ [Importar imágenes desde un ordenador local](md-create-dataset-computer.md)
+ [Utilizar un archivo de manifiesto para importar imágenes](md-create-dataset-ground-truth.md)
+ [Copia de contenido de un conjunto de datos existente](md-create-dataset-existing-dataset.md)
Si comienza su proyecto con conjuntos de datos de entrenamiento y prueba separados, podrá usar diferentes ubicaciones de origen para cada conjunto de datos.
Según el lugar desde el que importe las imágenes, es posible que no estén etiquetadas. Por ejemplo, las imágenes importadas de un ordenador local no están etiquetadas. Las imágenes importadas de un archivo de manifiesto de Amazon SageMaker AI Ground Truth están etiquetadas. Puede utilizar la consola de Etiquetas personalizadas de Amazon Rekognition para agregar, cambiar y asignar etiquetas. Para obtener más información, consulte [Etiquetado de imágenes](md-labeling-images.md).
Si las imágenes se cargan con errores, faltan imágenes o faltan etiquetas en las imágenes, lea [Depuración de un modelo de entrenamiento con errores](tm-debugging.md).
Para obtener más información sobre los conjuntos de datos, consulte [Administración de conjuntos de datos](managing-dataset.md).
## Crear conjuntos de datos de entrenamiento y prueba (SDK)
Puede usar el AWS SDK para crear conjuntos de datos de entrenamiento y prueba.
La operación `CreateDataset` le permite especificar etiquetas de forma opcional al crear un nuevo conjunto de datos con el fin de categorizar y administrar sus recursos.
### Conjunto de datos de entrenamiento
Puedes usar el AWS SDK para crear un conjunto de datos de entrenamiento de las siguientes maneras.
+ [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)Utilícelo con un archivo de manifiesto en formato Amazon Sagemaker que proporcione. Para obtener más información, consulte [Creación de un archivo de manifiesto](md-create-manifest-file.md). Para ver el código de ejemplo, consulte [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Use `CreateDataset` para copiar un conjunto de datos existente de Etiquetas personalizadas de Amazon Rekognition. Para ver el código de ejemplo, consulte [Creación de un conjunto de datos mediante un conjunto de datos existente (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Cree un conjunto de datos vacío con `CreateDataset` y agregue entradas del conjunto de datos más adelante con [UpdateDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UpdateDatasetEntries). Para crear un conjunto de datos vacío, consulte [Agregar un conjunto de datos a un proyecto](md-add-dataset.md). Para agregar imágenes a un conjunto de datos, consulte [Agregar más imágenes (SDK)](md-add-images.md#md-add-images-sdk). Debe agregar las entradas del conjunto de datos antes de poder entrenar un modelo.
### Conjunto de datos de prueba
Puede usar el AWS SDK para crear un conjunto de datos de prueba de las siguientes maneras:
+ [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)Utilícelo con un archivo de manifiesto en formato Amazon Sagemaker que proporcione. Para obtener más información, consulte [Creación de un archivo de manifiesto](md-create-manifest-file.md). Para ver el código de ejemplo, consulte [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Use `CreateDataset` para copiar un conjunto de datos existente de Etiquetas personalizadas de Amazon Rekognition. Para ver el código de ejemplo, consulte [Creación de un conjunto de datos mediante un conjunto de datos existente (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Cree un conjunto de datos vacío con `CreateDataset` y agregue entradas del conjunto de datos más adelante con `UpdateDatasetEntries`. Para crear un conjunto de datos vacío, consulte [Agregar un conjunto de datos a un proyecto](md-add-dataset.md). Para agregar imágenes a un conjunto de datos, consulte [Agregar más imágenes (SDK)](md-add-images.md#md-add-images-sdk). Debe agregar las entradas del conjunto de datos antes de poder entrenar un modelo.
+ Divida el conjunto de datos de entrenamiento en conjuntos de datos de entrenamiento y prueba independientes. En primer lugar, cree un conjunto de datos de prueba vacío con `CreateDataset`. A continuación, mueva el 20% de las entradas del conjunto de datos de entrenamiento al conjunto de datos de prueba mediante una llamada [DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries). Para crear un conjunto de datos vacío, consulte [Agregar un conjunto de datos a un proyecto (SDK)](md-add-dataset.md#md-add-dataset-sdk). Para dividir el conjunto de datos de entrenamiento, consulte [Distribución de un conjunto de datos de entrenamiento (SDK)](md-distributing-datasets.md).
# Importar imágenes desde un bucket de Amazon S3
Las imágenes se importan desde un bucket de Amazon S3. Puede usar el bucket de consola u otro bucket de Amazon S3 de su AWS cuenta. Si utiliza el bucket de consola, los permisos necesarios ya estarán configurados. Si no utiliza el bucket de consola, consulte [Acceso a buckets de Amazon S3 externos](su-console-policy.md#su-external-buckets).
**nota**
No puede usar el AWS SDK para crear un conjunto de datos directamente a partir de las imágenes de un bucket de Amazon S3. En su lugar, cree un archivo de manifiesto que haga referencia a las ubicaciones de origen de las imágenes. Para obtener más información, consulte [Utilizar un archivo de manifiesto para importar imágenes](md-create-dataset-ground-truth.md)
Durante la creación del conjunto de datos, puede optar por asignar nombres de etiquetas a las imágenes en función del nombre de la carpeta que contiene las imágenes. Las carpetas deben ser secundarias en la ruta de carpeta de Amazon S3 que indique en la **ubicación de la carpeta S3** durante la creación del conjunto de datos. Para crear un conjunto de datos, consulte [Crear un conjunto de datos mediante la importación de imágenes de un bucket de S3](#cd-procedure).
Por ejemplo, supongamos que un bucket de Amazon S3 tiene la siguiente estructura de carpetas. Si indica la ubicación de la carpeta de Amazon S3 como *S3-bucket/alexa-devices*, a las imágenes de la carpeta *echo* se les asigna la etiqueta *echo*. Del mismo modo, a las imágenes de la carpeta *echo-dot* se les asigna la etiqueta *echo-dot*. Los nombres de las carpetas secundarias de más abajo no se utilizan para etiquetar las imágenes. En su lugar, se utiliza la carpeta secundaria correspondiente a la ubicación de la carpeta de Amazon S3. Por ejemplo, a las imágenes de la carpeta *white-echo-dots*se les asigna la etiqueta *echo-dot*. Las imágenes que se encuentran en el nivel de la ubicación de la carpeta S3 (*alexa-devices*) no tienen etiquetas asignadas.
Las carpetas de más abajo de la estructura de carpetas se pueden usar para etiquetar las imágenes si se indica una ubicación más abajo de la carpeta S3. Por ejemplo, si especifica *S3- bucket/alexa-devices/echo -dot*, las imágenes de la carpeta *white-echo-dot*se etiquetan. *white-echo-dot* Las imágenes que se encuentren fuera de la ubicación de la carpeta s3 indicada, como *echo*, no se importan.
```
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
├── .
└── .
```
Le recomendamos que utilice el bucket de Amazon S3 (bucket de consola) que Amazon Rekognition creó para usted la primera vez que abrió la consola en la región actual. AWS Si el bucket de Amazon S3 que está utilizando es diferente (externo) al bucket de la consola, la consola le solicitará que configure los permisos adecuados durante la creación del conjunto de datos. Para obtener más información, consulte [Paso 2: Configurar los permisos de la consola de Etiquetas personalizadas de Amazon Rekognition](su-console-policy.md).
## Crear un conjunto de datos mediante la importación de imágenes de un bucket de S3
En el siguiente procedimiento, se explica cómo crear un conjunto de datos utilizando imágenes almacenadas en el bucket de consola de S3. Las imágenes se etiquetan automáticamente con el nombre de la carpeta en la que se almacenan.
Una vez importadas las imágenes, puede agregar más imágenes, asignar etiquetas y agregar cuadros delimitadores en la página de la galería de un conjunto de datos. Para obtener más información, consulte [Etiquetado de imágenes](md-labeling-images.md).
**Cargar las imágenes en un bucket de Amazon Simple Storage Service**
1. Cree una carpeta en el sistema de archivos local. Use un nombre de carpeta como *alexa-devices*.
1. Dentro de la carpeta que acabe de crear, cree carpetas con el nombre de cada etiqueta que quiera usar. Por ejemplo, *echo* y *echo-dot*. La estructura debería tener un aspecto similar al siguiente.
```
alexa-devices
├── echo
│ ├── echo-image-1.png
│ ├── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
1. Coloque las imágenes que se correspondan con una etiqueta en la carpeta con el mismo nombre de etiqueta.
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. [Añada la carpeta](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) que creó en el paso 1 al bucket de Amazon S3 (bucket de consola) que Etiquetas personalizadas de Amazon Rekognition crearon para usted durante la *primera configuración*. Para obtener más información, consulte [Administración de un proyecto de Etiquetas personalizadas de Amazon Rekognition](managing-project.md).
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto al que desee añadir el conjunto de datos. Se abrirá la página de detalles del proyecto.
1. Elija **Crear conjunto de datos**. Se abrirá la página **Crear conjunto de datos**.
1. En **Configuración inicial**, seleccione **Empezar con un único conjunto de datos** o **Empezar con un conjunto de datos de entrenamiento**. Para crear un modelo de mayor calidad, le recomendamos empezar con conjuntos de datos de entrenamiento y de prueba independientes.
------
#### [ Single dataset ]
1. En la sección **Detalles del conjunto de datos de entrenamiento**, seleccione **Importar imágenes del bucket de S3**.
1. En la sección **Detalles del conjunto de datos de entrenamiento**, introduzca la información de los pasos 13 al 15 de la sección de **Configuración de la fuente de la imagen**.
------
#### [ Separate training and test datasets ]
1. En la sección **Detalles del conjunto de datos de entrenamiento**, seleccione **Importar imágenes del bucket de S3**.
1. En la sección **Detalles del conjunto de datos de entrenamiento**, introduzca la información de los pasos 13 al 15 de la sección de **Configuración de la fuente de la imagen**.
1. En la sección **Detalles del conjunto de datos de prueba**, seleccione **Importar imágenes del bucket de S3**.
1. En la sección **Detalles del conjunto de datos de prueba**, introduzca la información de los pasos 13 al 15 de la sección de **Configuración de la fuente de la imagen**.
------
1. Seleccione **Importar imágenes del bucket de Amazon S3**.
1. En el **URI de S3**, introduzca la ubicación del bucket de Amazon S3 y la ruta de la carpeta.
1. Seleccione **Adjuntar etiquetas automáticamente a las imágenes en función de la carpeta**.
1. Elija **Crear conjuntos de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
1. Si necesita agregar o cambiar etiquetas, consulte [Etiquetado de imágenes](md-labeling-images.md).
1. Siga los pasos que se indican en [Entrenamiento de un modelo (consola)](training-model.md#tm-console) para entrenar el modelo.
# Importar imágenes desde un ordenador local
Las imágenes se cargan directamente desde el ordenador. Puede cargar hasta 30 imágenes a la vez.
Las imágenes que suba no tendrán etiquetas asociadas. Para obtener más información, consulte [Etiquetado de imágenes](md-labeling-images.md). Si tiene que cargar muchas imágenes, considere la posibilidad de utilizar un bucket de Amazon S3. Para obtener más información, consulte [Importar imágenes desde un bucket de Amazon S3](md-create-dataset-s3.md).
**nota**
No puede usar el AWS SDK para crear un conjunto de datos con imágenes locales. En su lugar, cree un archivo de manifiesto y cargue las imágenes en un bucket de Amazon S3. Para obtener más información, consulte [Utilizar un archivo de manifiesto para importar imágenes](md-create-dataset-ground-truth.md).
**Para crear un conjunto de datos con imágenes en un equipo local (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto al que desee añadir el conjunto de datos. Se abrirá la página de detalles del proyecto.
1. Elija **Crear conjunto de datos**. Se abrirá la página **Crear conjunto de datos**.
1. En **Configuración inicial**, seleccione **Empezar con un único conjunto de datos** o **Empezar con un conjunto de datos de entrenamiento**. Para crear un modelo de mayor calidad, le recomendamos empezar con conjuntos de datos de entrenamiento y de prueba independientes.
------
#### [ Single dataset ]
1. En la **sección de detalles del conjunto de datos de entrenamiento**, seleccione **Cargar imágenes del ordenador**.
1. Elija **Crear conjunto de datos**.
1. En la página del conjunto de datos del proyecto, seleccione **Agregar imágenes**.
1. Escoja las imágenes que quiera cargar en el conjunto de datos de los archivos del ordenador. Puede arrastrar las imágenes o elegir las imágenes deseadas de su equipo local.
1. Seleccione **Cargar imágenes**.
------
#### [ Separate training and test datasets ]
1. En la **sección de detalles del conjunto de datos de entrenamiento**, seleccione **Cargar imágenes del ordenador**.
1. En la sección **Detalles del conjunto de datos de prueba**, seleccione **Cargar imágenes desde el equipo**.
**nota**
Los conjuntos de datos de entrenamiento y de prueba pueden tener diferentes fuentes de imágenes.
1. Elija **Crear conjuntos de datos**. La página de conjuntos de datos del proyecto incluye la pestaña **Entrenamiento** y la pestaña **Prueba** para los conjuntos de datos respectivos.
1. Seleccione **Acciones** y luego **Agregar imágenes al conjunto de datos de entrenamiento**.
1. Escoja las imágenes que quiera cargar en el conjunto de datos. Puede arrastrar las imágenes o elegir las imágenes deseadas de su equipo local.
1. Seleccione **Cargar imágenes**.
1. Repita los pasos del 5e al 5g. En el paso 5e, seleccione **Acciones** y luego **Agregar imágenes al conjunto de datos de entrenamiento**.
------
1. Siga los pasos que se indican en [Etiquetado de imágenes](md-labeling-images.md) para etiquetar las imágenes.
1. Siga los pasos que se indican en [Entrenamiento de un modelo (consola)](training-model.md#tm-console) para entrenar su modelo.
# Utilizar un archivo de manifiesto para importar imágenes
Puede crear un conjunto de datos con un archivo de manifiesto en formato Amazon SageMaker AI Ground Truth. Puedes usar el archivo de manifiesto de un trabajo de Amazon SageMaker AI Ground Truth. Si tus imágenes y etiquetas no tienen el formato de un archivo de manifiesto de SageMaker AI Ground Truth, puedes crear un archivo de manifiesto en formato SageMaker AI y usarlo para importar las imágenes etiquetadas.
La operación `CreateDataset` se actualiza para que pueda especificar etiquetas de forma opcional al crear un nuevo conjunto de datos. Las etiquetas son pares clave-valor que puede usar para categorizar y administrar sus recursos.
**Topics**
+ [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](#md-create-dataset-ground-truth-console)
+ [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](#md-create-dataset-ground-truth-sdk)
+ [Crear una solicitud de conjunto de datos](#create-dataset-ground-truth-request)
+ [Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md)
+ [Creación de un archivo de manifiesto](md-create-manifest-file.md)
+ [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md)
+ [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md)
+ [Reglas de validación de archivos de manifiesto](md-create-manifest-file-validation-rules.md)
+ [Convertir otros formatos de conjunto de datos en un archivo de manifiesto](md-converting-to-sm-format.md)
## Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)
El siguiente procedimiento muestra cómo crear un conjunto de datos mediante un archivo de manifiesto en formato SageMaker AI Ground Truth.
1. Cree un archivo de manifiesto para el conjunto de datos de entrenamiento de la siguiente manera:
+ Cree un archivo de manifiesto con un SageMaker AI GroundTruth Job siguiendo las instrucciones de[Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Cree su propio archivo de manifiesto siguiendo las instrucciones de [Creación de un archivo de manifiesto](md-create-manifest-file.md).
Si quiere crear un conjunto de datos de prueba, repita el paso 1 para crear el conjunto de datos de prueba.
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto al que desee añadir el conjunto de datos. Se abrirá la página de detalles del proyecto.
1. Elija **Crear conjunto de datos**. Se abrirá la página **Crear conjunto de datos**.
1. En **Configuración inicial**, seleccione **Empezar con un único conjunto de datos** o **Empezar con un conjunto de datos de entrenamiento**. Para crear un modelo de mayor calidad, le recomendamos empezar con conjuntos de datos de entrenamiento y de prueba independientes.
------
#### [ Single dataset ]
1. En la sección de **detalles del conjunto de datos de entrenamiento**, selecciona **Importar imágenes etiquetadas por SageMaker Ground Truth**.
1. En la **ubicación del archivo de manifiesto**, introduzca la ubicación del archivo de manifiesto que creó en el paso 1.
1. Elija **Crear conjunto de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
------
#### [ Separate training and test datasets ]
1. En la sección de **detalles del conjunto de datos de entrenamiento**, selecciona **Importar imágenes etiquetadas por SageMaker Ground Truth**.
1. En la **ubicación del archivo de manifiesto**, introduzca la ubicación del archivo de manifiesto del conjunto de datos de entrenamiento que creó en el paso 1.
1. En la sección **Detalles del conjunto de datos de prueba**, selecciona **Importar imágenes etiquetadas por SageMaker Ground Truth**.
**nota**
Los conjuntos de datos de entrenamiento y de prueba pueden tener diferentes fuentes de imágenes.
1. En la **ubicación del archivo de manifiesto**, introduzca la ubicación del archivo de manifiesto del conjunto de datos de prueba que creó en el paso 1.
1. Elija **Crear conjuntos de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
------
1. Si necesita agregar o cambiar etiquetas, consulte [Etiquetado de imágenes](md-labeling-images.md).
1. Siga los pasos que se indican en [Entrenamiento de un modelo (consola)](training-model.md#tm-console) para entrenar el modelo.
## Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth
El siguiente procedimiento muestra cómo crear conjuntos de datos de entrenamiento o prueba a partir de un archivo de manifiesto mediante la [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)API.
Puedes usar un archivo de manifiesto existente, como el resultado de un [trabajo de SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md), o crear tu propio [archivo de manifiesto](md-create-manifest-file.md).
1. Si aún no lo has hecho, instala y configura el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 4: Configure y AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Cree un archivo de manifiesto para el conjunto de datos de entrenamiento de la siguiente manera:
+ Cree un archivo de manifiesto con un SageMaker AI GroundTruth Job siguiendo las instrucciones de[Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Cree su propio archivo de manifiesto siguiendo las instrucciones de [Creación de un archivo de manifiesto](md-create-manifest-file.md).
Si quiere crear un conjunto de datos de prueba, repita el paso 2 para crear el conjunto de datos de prueba.
1. Use el siguiente código de ejemplo para crear el conjunto de datos de entrenamiento y prueba.
------
#### [ AWS CLI ]
Cree un conjunto de datos con el siguiente código. Sustituya lo siguiente:
+ `project_arn`: el ARN del proyecto al que desea agregar el conjunto de datos de prueba.
+ `type`: el tipo de conjunto de datos que desea crear (ENTRENAMIENTO o PRUEBA).
+ `bucket`: el bucket que contiene el archivo de manifiesto del conjunto de datos.
+ `manifest_file`: el nombre de archivo y la ruta del archivo de manifiesto.
```
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 ]
Cree un conjunto de datos con los siguientes valores. Indique los siguientes parámetros de línea de comandos:
+ `project_arn`: el ARN del proyecto al que desea agregar el conjunto de datos de prueba.
+ `dataset_type`: el tipo de conjunto de datos que desea crear (`train` o `test`).
+ `bucket`: el bucket que contiene el archivo de manifiesto del conjunto de datos.
+ `manifest_file`: el nombre de archivo y la ruta del archivo de manifiesto.
```
#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 ]
Cree un conjunto de datos con los siguientes valores. Indique los siguientes parámetros de línea de comandos:
+ `project_arn`: el ARN del proyecto al que desea agregar el conjunto de datos de prueba.
+ `dataset_type`: el tipo de conjunto de datos que desea crear (`train` o `test`).
+ `bucket`: el bucket que contiene el archivo de manifiesto del conjunto de datos.
+ `manifest_file`: el nombre de archivo y la ruta del archivo de manifiesto.
```
/*
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. Si necesita agregar o cambiar etiquetas, consulte [Administración de etiquetas (SDK)](md-labels.md#md-labels-sdk).
1. Siga los pasos que se indican en [Entrenamiento de un modelo (SDK)](training-model.md#tm-sdk) para entrenar el modelo.
## Crear una solicitud de conjunto de datos
El formato de la solicitud de CreateDataset operación es el siguiente:
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```
# Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth
Con Amazon SageMaker AI Ground Truth, puede utilizar trabajadores de Amazon Mechanical Turk, una empresa proveedora que elija, o de una fuerza laboral interna y privada, junto con el aprendizaje automático que le permite crear un conjunto de imágenes etiquetadas. Amazon Rekognition Custom Labels importa los archivos de manifiesto de SageMaker AI Ground Truth desde un bucket de Amazon S3 que especifique.
Las etiquetas personalizadas Amazon Rekognition son compatibles con las siguientes tareas de SageMaker AI Ground Truth.
+ [Clasificación de imágenes](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification.html)
+ [Cuadro delimitador](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-bounding-box.html)
Los archivos que importe son las imágenes y un archivo de manifiesto. El archivo de manifiesto contiene información sobre las etiquetas y los cuadros delimitadores de las imágenes que importe.
Amazon Rekognition necesita permisos para acceder al bucket de Amazon S3 donde se almacenan las imágenes. Si utiliza el bucket de consola configurado por Etiquetas personalizadas de Amazon Rekognition, los permisos necesarios ya estarán configurados. Si no utiliza el bucket de consola, consulte [Acceso a buckets de Amazon S3 externos](su-console-policy.md#su-external-buckets).
## Creación de un archivo de manifiesto con un trabajo de SageMaker AI Ground Truth (consola)
El siguiente procedimiento muestra cómo crear un conjunto de datos mediante imágenes etiquetadas por un trabajo de SageMaker AI Ground Truth. Los archivos finales de los trabajos se almacenan en el bucket de consola de Etiquetas personalizadas de Amazon Rekognition.
**Para crear un conjunto de datos con imágenes etiquetadas por un trabajo de SageMaker AI Ground Truth (consola)**
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En el bucket de consola, [cree una carpeta](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) para guardar las imágenes de entrenamiento.
**nota**
El bucket de consola se crea al abrir por primera vez la consola Amazon Rekognition Custom Labels en una región. AWS Para obtener más información, consulte [Administración de un proyecto de Etiquetas personalizadas de Amazon Rekognition](managing-project.md).
1. [Cargue sus imágenes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) en la carpeta que acaba de crear.
1. En el bucket de consola, cree una carpeta para guardar el resultado del trabajo de Ground Truth.
1. Abra la consola de SageMaker IA en. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)
1. Cree un trabajo de etiquetado de Ground Truth. Necesitará Amazon S3 URLs para las carpetas que creó en los pasos 2 y 4. Para obtener más información, consulta Cómo [usar Amazon SageMaker Ground Truth para el etiquetado de datos](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html).
1. Anote la ubicación del archivo `output.manifest` en la carpeta que creó en el paso 4. Debe estar en la subcarpeta `Ground-Truth-Job-Name/manifests/output`.
1. Siga las instrucciones que aparecen en [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para crear un conjunto de datos con el archivo de manifiesto cargado. Para el paso 8, en la **ubicación del archivo de manifiesto**, introduzca la URL de Amazon S3 para la ubicación que anotó en el paso anterior. Si está utilizando el AWS SDK, hágalo[Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
1. Repite los pasos 1 a 6 para crear el trabajo SageMaker AI Ground Truth para tu conjunto de datos de prueba.
# Creación de un archivo de manifiesto
Puedes crear un conjunto de datos de prueba o entrenamiento importando un archivo de manifiesto en formato SageMaker AI Ground Truth. Si tus imágenes están etiquetadas en un formato que no es un archivo de manifiesto de SageMaker AI Ground Truth, usa la siguiente información para crear un archivo de manifiesto en formato SageMaker AI Ground Truth.
Los archivos de manifiesto están en formato de [líneas JSON](http://jsonlines.org), donde cada línea es un objeto JSON completo que representa la información de etiquetado de una imagen. Las etiquetas personalizadas de Amazon Rekognition admiten los manifiestos de SageMaker AI Ground Truth con líneas JSON en los siguientes formatos:
+ [Resultado del trabajo de clasificación](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class): sirve para agregar etiquetas de imagen a una imagen. Una etiqueta de imagen define la clase de escena, concepto u objeto (si no se necesita la información sobre la ubicación del objeto) que hay en una imagen. Una imagen puede tener más de una etiqueta de imagen. Para obtener más información, consulte [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md).
+ [Resultado del trabajo del cuadro delimitador](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box): sirve para etiquetar la clase y la ubicación de uno o varios objetos en una imagen. Para obtener más información, consulte [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
Las líneas JSON de imagen y de localización (cuadro delimitador) se pueden encadenar en el mismo archivo de manifiesto.
**nota**
Se ha cambiado el formato de los ejemplos de las líneas JSON de esta sección para facilitar su lectura.
Al importar un archivo de manifiesto, Etiquetas personalizadas de Amazon Rekognition aplica reglas de validación para los límites, la sintaxis y la semántica. Para obtener más información, consulte [Reglas de validación de archivos de manifiesto](md-create-manifest-file-validation-rules.md).
Las imágenes a las que hace referencia un archivo de manifiesto deben estar ubicadas en el mismo bucket de Amazon S3. El archivo de manifiesto puede estar ubicado en un bucket de Amazon S3 distinto al que almacena las imágenes. Debe indicar la ubicación de una imagen en el campo `source-ref` de una línea JSON.
Amazon Rekognition necesita permisos para acceder al bucket de Amazon S3 donde se almacenan las imágenes. Si utiliza el bucket de consola configurado por Etiquetas personalizadas de Amazon Rekognition, los permisos necesarios ya estarán configurados. Si no utiliza el bucket de consola, consulte [Acceso a buckets de Amazon S3 externos](su-console-policy.md#su-external-buckets).
**Topics**
+ [Creación de un archivo de manifiesto](#md-create-manifest-file-console)
## Creación de un archivo de manifiesto
Con el siguiente procedimiento se puede crear un proyecto con un conjunto de datos de entrenamiento y prueba. Los conjuntos de datos se crean a partir de los archivos de manifiesto de entrenamiento y prueba que se creen.
**Para crear un conjunto de datos con un archivo de manifiesto en formato SageMaker AI Ground Truth (consola)**
1. En el bucket de consola, [cree una carpeta](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) para guardar los archivos de manifiesto.
1. En el bucket de consola, cree una carpeta para guardar las imágenes.
1. Cargue su imágenes en la carpeta que acaba de crear.
1. Crea un archivo de manifiesto en formato SageMaker AI Ground Truth para tu conjunto de datos de entrenamiento. Para obtener más información, consulte [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md) y [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
**importante**
El valor del campo `source-ref` de cada línea JSON debe asignarse a una imagen que haya cargado.
1. Crea un archivo de manifiesto en formato SageMaker AI Ground Truth para tu conjunto de datos de prueba.
1. [Cargue los archivos de manifiesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) en la carpeta que acaba de crear.
1. Anote la ubicación del archivo de manifiesto.
1. Siga las instrucciones que aparecen en [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para crear un conjunto de datos con el archivo de manifiesto cargado. Para el paso 8, en la **ubicación del archivo de manifiesto**, introduzca la URL de Amazon S3 para la ubicación que anotó en el paso anterior. Si utilizas el AWS SDK, hazlo[Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Importación de etiquetas de imagen en los archivos de manifiesto
Para importar etiquetas a nivel de imagen (imágenes etiquetadas con escenas, conceptos u objetos que no requieren información de localización), añada líneas JSON en formato JSON en formato SageMaker AI Ground Truth [Classification Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class) a un archivo de manifiesto. Un archivo de manifiesto está compuesto por una o varias líneas JSON, una para cada imagen que desee importar.
**sugerencia**
Para facilitar la creación de un archivo de manifiesto, habilitamos un script de Python que crea un archivo de manifiesto a partir de un archivo CSV. Para obtener más información, consulte [Creación de un archivo de manifiesto a partir de un archivo CSV](ex-csv-manifest.md).
**Cómo crear un archivo de manifiesto para etiquetas de imagen**
1. Cree un archivo de texto vacío.
1. Añada una línea JSON por cada imagen que desee importar. La línea JSON debería tener un aspecto similar al siguiente.
```
{"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. Guarde el archivo. Puede usar la extensión `.manifest`, pero no es obligatoria.
1. Cree un conjunto de datos con el archivo de manifiesto que creó. Para obtener más información, consulte [Para crear un conjunto de datos con un archivo de manifiesto en formato SageMaker AI Ground Truth (consola)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## Líneas JSON de imagen
En esta sección, le indicamos cómo crear una línea JSON para una sola imagen. Analice la siguiente imagen. La escena para la siguiente imagen podría llamarse *Amanecer*.
![\[Puesta de sol sobre un lago con un muelle y pequeñas embarcaciones, rodeado de montañas.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/sunrise.png)
La línea JSON de la imagen anterior, con la escena *Amanecer*, podría ser la siguiente.
```
{
"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"
}
}
```
Observe la siguiente información.
### source-ref
(Obligatorio) La ubicación de Amazon S3 de la imagen. El formato es `"s3://BUCKET/OBJECT_PATH"`. Las imágenes de un conjunto de datos importado deben almacenarse en el mismo bucket de Amazon S3.
### *testdataset-classification\$1Sunrise*
(Obligatorio) El atributo de etiqueta. Elija el nombre del campo. El valor del campo (1 en el ejemplo anterior) es un identificador de atributo de etiqueta. No lo utilizan Etiquetas personalizadas de Amazon Rekognition y puede ser cualquier valor entero. Deben estar presentes los metadatos correspondientes identificados por el nombre del campo con el parámetro *-metadata* adjunto. Por ejemplo, `"testdataset-classification_Sunrise-metadata"`.
### *testdataset-classification\$1Sunrise*-metadatos
(Obligatorio) Metadatos sobre el atributo de etiqueta. El nombre del campo debe ser el mismo que el del atributo de etiqueta con *-metadata* anexado.
*confidence*
(Obligatorio) Etiquetas personalizadas de Amazon Rekognition no lo utiliza actualmente, pero se debe indicar un valor entre 0 y 1.
*job-name*
(Opcional) Un nombre que elija para el trabajo que procesa la imagen.
*class-name*
(Obligatorio) El nombre de clase que se elige para la escena o el concepto que se aplica a la imagen. Por ejemplo, `"Sunrise"`.
*human-annotated*
(Obligatorio) Indique `"yes"` si la anotación la ha completado un humano. De lo contrario, `"no"`.
*creation-date*
(Obligatorio) La fecha y la hora en que se creó la etiqueta, según la hora universal coordinada (UTC).
*type*
(Obligatorio) El tipo de procesamiento que se debe aplicar a la imagen. En el caso de las etiquetas de imagen, el valor es `"groundtruth/image-classification"`.
### Cómo agregar varias etiquetas de imagen a una imagen
Puede agregar varias etiquetas a una imagen. Por ejemplo, el siguiente JSON agrega dos etiquetas, *fútbol* y *pelota*, a una sola imagen.
```
{
"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
```
# Localización de objetos en archivos de manifiesto
Puedes importar imágenes etiquetadas con información de localización de objetos añadiendo líneas JSON en formato SageMaker AI Ground [Truth Bounding Box Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) a un archivo de manifiesto.
La información de la localización representa la ubicación de un objeto en una imagen. La ubicación se representa mediante un cuadro delimitador que rodea el objeto. La estructura del cuadro delimitador incluye las coordenadas superiores izquierdas del cuadro delimitador y su ancho y alto. Una línea JSON con formato de cuadro delimitador incluye los cuadros delimitadores de las ubicaciones de uno o varios objetos en una imagen y la clase de cada objeto de la imagen.
Un archivo de manifiesto está compuesto por una o varias líneas JSON y cada línea contiene la información de una sola imagen.
**Cómo crear un archivo de manifiesto para la localización de objetos**
1. Cree un archivo de texto vacío.
1. Añada una línea JSON por cada imagen que desee importar. La línea JSON debería tener un aspecto similar al siguiente.
```
{"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. Guarde el archivo. Puede usar la extensión `.manifest`, pero no es obligatoria.
1. Cree un conjunto de datos con el archivo que creó. Para obtener más información, consulte [Para crear un conjunto de datos con un archivo de manifiesto en formato SageMaker AI Ground Truth (consola)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## Líneas JSON de cuadros delimitadores de objetos
En esta sección, le indicamos cómo crear una línea JSON para una sola imagen. Por ejemplo, en la siguiente imagen se ven unos cuadros delimitadores alrededor de un Amazon Echo y un Amazon Echo Dot.
![\[Dos altavoces inteligentes Amazon, uno con cuadro delimitador verde y otro con cuadro delimitador azul, sobre una superficie de madera.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/echos.png)
La siguiente es la línea JSON del cuadro delimitador de la imagen anterior.
```
{
"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"
}
}
```
Observe la siguiente información.
### source-ref
(Obligatorio) La ubicación de Amazon S3 de la imagen. El formato es `"s3://BUCKET/OBJECT_PATH"`. Las imágenes de un conjunto de datos importado deben almacenarse en el mismo bucket de Amazon S3.
### *bounding-box*
(Obligatorio) El atributo de etiqueta. Elija el nombre del campo. Incluye el tamaño de la imagen y los cuadros delimitadores de cada objeto detectado en la imagen. Deben estar presentes los metadatos correspondientes identificados por el nombre del campo con el parámetro *-metadata* adjunto. Por ejemplo, `"bounding-box-metadata"`.
*image\$1size*
(Obligatorio) Una matriz de un solo elemento que contiene el tamaño de la imagen en píxeles.
+ *height*: (obligatorio) la altura de la imagen en píxeles.
+ *width*: (obligatorio) la profundidad de la imagen en píxeles.
+ *depth*: (obligatorio) el número de canales de la imagen. En la caso de las imágenes RGB, el valor es 3. Etiquetas personalizadas de Amazon Rekognition no lo utiliza actualmente, pero se debe indicar un valor.
*annotations*
(Obligatorio) Un conjunto de información sobre los cuadros delimitadores de cada objeto detectado en la imagen.
+ *class\$1id*: (obligatorio) se asigna a la etiqueta en *class-map*. En el ejemplo anterior, el objeto con el *class\$1id* de `1` es el Echo Dot de la imagen.
+ *top*: (obligatorio) la distancia desde la parte superior de la imagen hasta la parte superior del cuadro delimitador, en píxeles.
+ *left*: (obligatorio) la distancia desde la izquierda de la imagen hasta la izquierda del cuadro delimitador, en píxeles.
+ *width*: (obligatorio) el ancho del cuadro delimitador, en píxeles.
+ *height*: (obligatorio) la altura del cuadro delimitador, en píxeles.
### *bounding-box*-metadatos
(Obligatorio) Metadatos sobre el atributo de etiqueta. El nombre del campo debe ser el mismo que el del atributo de etiqueta con el parámetro *-metadata* adjunto. Un conjunto de información sobre los cuadros delimitadores de cada objeto detectado en la imagen.
*Objects*
(Obligatorio) Una matriz de objetos presente en la imagen. Se asigna a la matriz de *annotations* por índice. Etiquetas personalizadas de Amazon Rekognition no utiliza el atributo confidence.
*class-map*
(Obligatorio) El mapa de clases que se aplica a los objetos detectados en la imagen.
*type*
(Obligatorio) El tipo de trabajo de clasificación. `"groundtruth/object-detection"` identifica el trabajo como detección de objetos.
*creation-date*
(Obligatorio) La fecha y la hora en que se creó la etiqueta, según la hora universal coordinada (UTC).
*human-annotated*
(Obligatorio) Indique `"yes"` si la anotación la ha completado un humano. De lo contrario, `"no"`.
*job-name*
(Opcional) El nombre del trabajo que procesa la imagen.
# Reglas de validación de archivos de manifiesto
Al importar un archivo de manifiesto, Etiquetas personalizadas de Amazon Rekognition aplica reglas de validación para los límites, la sintaxis y la semántica. El esquema SageMaker AI Ground Truth impone la validación de la sintaxis. Para obtener más información, consulte [Salida](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html). Las siguientes son las reglas de validación de los límites y la semántica.
**nota**
Las reglas de invalidez del 20 % se aplican de forma acumulativa a todas las reglas de validación. Si la importación supera el límite del 20 % debido a alguna combinación (por ejemplo, un 15 % de JSON no válido y un 15 % de imágenes no válidas), se producirá un error en la importación.
Cada objeto del conjunto de datos es una línea del manifiesto. Las líneas en blanco o no válidas también se cuentan como objetos del conjunto de datos.
Las superposiciones son (etiquetas comunes entre la prueba y el entrenamiento)/(etiquetas de entrenamiento).
**Topics**
+ [Límites](#md-validation-rules-limits)
+ [Semántica](#md-validation-rules-semantics)
## Límites
| Validación | Límite | Se ha producido un error |
| --- | --- | --- |
| Tamaño del archivo de manifiesto | 1 GB máximo | Error |
| Número máximo de líneas para un archivo de manifiesto | Máximo de 250 000 objetos de conjunto de datos como líneas en un manifiesto. | Error |
| Límite inferior del número total de objetos de conjunto de datos válidos por etiqueta | >= 1 | Error |
| Límite inferior de etiquetas | 2 | Error |
| Límite superior de etiquetas | <= 250 | Error |
| Número mínimo de cuadros delimitadores por imagen | 0 | Ninguno |
| Número máximo de cuadros delimitadores por imagen | 50 | Ninguno |
## Semántica
| Validación | Límite | Se ha producido un error |
| --- | --- | --- |
| Manifiesto vacío | | Error |
| Falta el objeto source-ref o no se puede acceder a él | Número de objetos inferior al 20 % | Advertencia |
| Falta el objeto source-ref o no se puede acceder a él | Número de objetos > 20 % | Error |
| Las etiquetas de prueba no están presentes en el conjunto de datos de entrenamiento | Al menos un 50 % se superpone en las etiquetas | Error |
| Combinación de ejemplos de etiquetas y objetos para la misma etiqueta en un conjunto de datos. Clasificación y detección de la misma clase en un objeto de conjunto de datos. | | Sin errores ni advertencias |
| Superposición de activos entre la prueba y el entrenamiento | No debe haber una superposición entre los conjuntos de datos de prueba y de entrenamiento. | |
| Las imágenes de un conjunto de datos deben proceder del mismo bucket | Se produce un error si los objetos están en un bucket diferente | Error |
# Convertir otros formatos de conjunto de datos en un archivo de manifiesto
Puede utilizar la siguiente información para crear archivos de manifiesto en formato Amazon SageMaker AI a partir de diversos formatos de conjuntos de datos de origen. Después de crear el archivo de manifiesto, úselo para crear un conjunto de datos. Para obtener más información, consulte [Utilizar un archivo de manifiesto para importar imágenes](md-create-dataset-ground-truth.md).
**Topics**
+ [Transformar un conjunto de datos COCO en un formato de archivo de manifiesto](md-transform-coco.md)
+ [Transformación de los archivos de manifiesto de SageMaker AI Ground Truth con múltiples etiquetas](md-gt-cl-transform.md)
+ [Creación de un archivo de manifiesto a partir de un archivo CSV](ex-csv-manifest.md)
# Transformar un conjunto de datos COCO en un formato de archivo de manifiesto
[COCO](http://cocodataset.org/#home) es un formato que indica conjuntos de datos de detección, segmentación y subtitulación de objetos a gran escala. En este [ejemplo](md-coco-transform-example.md) de Python se explica cómo transformar un conjunto de datos con formato de detección de objetos COCO en un [archivo de manifiesto con formato de cuadro delimitador](md-create-manifest-file-object-detection.md) de Etiquetas personalizadas de Amazon Rekognition. En esta sección también se incluye información que puede usar para escribir el código.
Un archivo JSON en formato COCO consta de cinco secciones que aportan información para *un conjunto de datos completo*. Para obtener más información, consulte [El formato del conjunto de datos COCO](md-coco-overview.md).
+ `info`: información general sobre el conjunto de datos.
+ `licenses `: información de las licencias de imágenes del conjunto de datos.
+ [`images`](md-coco-overview.md#md-coco-images): lista de imágenes del conjunto de datos.
+ [`annotations`](md-coco-overview.md#md-coco-annotations): lista de anotaciones (incluidos los cuadros delimitadores) que están presentes en todas las imágenes del conjunto de datos.
+ [`categories`](md-coco-overview.md#md-coco-categories): lista de categorías de etiquetas.
Necesitará información de las listas `images`, `annotations` y `categories` para crear un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition.
Un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition tiene un formato de líneas JSON, donde cada línea tiene el cuadro delimitador y la información de etiqueta de uno o varios objetos de *una imagen*. Para obtener más información, consulte [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
## Asignación de objetos COCO a una línea JSON de etiquetas personalizadas
Para transformar un conjunto de datos en formato COCO, asigne el conjunto de datos COCO a un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition para la localización de objetos. Para obtener más información, consulte [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md). Para crear una línea JSON para cada imagen, el archivo de manifiesto debe mapear el conjunto de datos `image` COCO y el campo `category` del objeto IDs. `annotation`
A continuación se muestra un ejemplo de un archivo de manifiesto COCO. Para obtener más información, consulte [El formato del conjunto de datos 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"}
]
}
```
En el siguiente diagrama, se indica cómo las listas del conjunto de datos COCO para un *conjunto de datos* se asignan a las líneas JSON de Etiquetas personalizadas de Amazon Rekognition para *una imagen*. Cada línea JSON de una imagen contiene un campo de referencia de origen, trabajo y metadatos de trabajo. Los colores iguales señalan la información de una sola imagen. Tenga en cuenta que, en el manifiesto, una imagen individual puede tener varias anotaciones y metadatos/categorías.
![\[Diagrama con la estructura de un manifiesto COCO que incluye imágenes, anotaciones y categorías.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/coco-transform.png)
**Cómo obtener los objetos COCO de una sola línea JSON**
1. En cada imagen de la lista de imágenes, obtenga la anotación de la lista de anotaciones en la que el valor del campo de anotación `image_id` coincida con el campo `id` de la imagen.
1. En cada anotación que coincida en el paso 1, revise la lista `categories` y obtenga cada `category` donde el valor `category` del campo `id` coincida con el campo `annotation` del objeto `category_id`.
1. Cree una línea JSON para la imagen utilizando los objetos `image`, `annotation` y `category` que coincidan. Para asignar los campos, consulte [Asignación de campos de objetos COCO a campos de objeto de una línea JSON de etiquetas personalizadas](#md-mapping-fields-coco).
1. Repita los pasos del 1 al 3 hasta que haya creado líneas JSON para cada objeto `image` de la lista `images`.
Para ver el código de ejemplo, consulte [Transformación de un conjunto de datos COCO](md-coco-transform-example.md).
## Asignación de campos de objetos COCO a campos de objeto de una línea JSON de etiquetas personalizadas
Tras identificar los objetos COCO de una línea JSON de Etiquetas personalizadas de Amazon Rekognition, debe asignar los campos de objetos COCO a los campos de objetos correspondientes de la línea JSON de Etiquetas personalizadas de Amazon Rekognition. En el siguiente ejemplo, la línea JSON de Etiquetas personalizadas de Amazon Rekognition asigna una línea de imagen (`id`=`000000245915`) al ejemplo anterior de JSON COCO. Observe la siguiente información.
+ `source-ref` es la ubicación de la imagen en un bucket de Amazon S3. Si las imágenes COCO no están almacenadas en un bucket de Amazon S3, debe moverlas a un bucket de Amazon S3.
+ La lista `annotations` contiene un objeto `annotation` por cada objeto de la imagen. Un objeto `annotation` incluye información sobre un cuadro delimitador (`top`, `left`, `width`, `height`) y un identificador de etiqueta (`class_id`).
+ El identificador de etiqueta (`class_id`) se asigna a la lista `class-map` en los metadatos. Aquí aparecen las etiquetas utilizadas en la imagen.
```
{
"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"
}
}
```
Utilice la siguiente información para asignar los campos del archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition a los campos JSON del conjunto de datos COCO.
### source-ref
La URL en formato S3 para la ubicación de la imagen. La imagen vídeo debe almacenarse en un bucket de S3. Para obtener más información, consulte [source-ref](md-create-manifest-file-object-detection.md#cd-manifest-source-ref). Si el campo COCO `coco_url` enlaza con una ubicación del bucket de S3, puede usar el valor de `coco_url` para el valor de `source-ref`. Como alternativa, puede asignar `source-ref` al campo `file_name` (COCO) y, en el código de transformación, agregar la ruta de S3 necesaria a la ubicación donde está almacenada la imagen.
### *bounding-box*
El nombre de atributo de etiqueta que elija. Para obtener más información, consulte [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box).
#### image\$1size
Tamaño de la imagen en píxeles. Se asigna a un objeto `image` de la lista de [imágenes](md-coco-overview.md#md-coco-images).
+ `height`-> `image.height`
+ `width`-> `image.width`
+ `depth`-> Etiquetas personalizadas de Amazon Rekognition no lo utiliza, pero se debe indicar un valor.
#### annotations
Una lista de objetos `annotation`. Hay un `annotation` por cada objeto de la imagen.
#### anotación
Contiene información sobre un cuadro delimitador para la instancia de un objeto de la imagen.
+ `class_id`-> Asignación de identificadores numéricos a la lista `class-map` de etiquetas personalizadas.
+ `top` -> `bbox[1]`
+ `left` -> `bbox[0]`
+ `width` -> `bbox[2]`
+ `height` -> `bbox[3]`
### *bounding-box*-metadatos
Metadatos del atributo de etiqueta. Incluye las etiquetas y los identificadores de etiquetas. Para obtener más información, consulte [*bounding-box*-metadatos](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### Objects
Una matriz de objetos de la imagen. Asigna la lista `annotations` por índice.
##### Objeto
+ `confidence`->Etiquetas personalizadas de Amazon Rekognition no lo utiliza, pero es obligatorio indicar un valor (1).
#### class-map
Un mapa de clases (classes) que se aplican a los objetos detectados en la imagen. Se asigna a los objetos de categoría de la lista de [categorías](md-coco-overview.md#md-coco-categories).
+ `id` -> `category.id`
+ `id value` -> `category.name`
#### type
Debe ser `groundtruth/object-detection`
#### human-annotated
Indique `yes` o `no`. Para obtener más información, consulte [*bounding-box*-metadatos](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
La fecha y hora de creación de la imagen. Se asigna al campo [image](md-coco-overview.md#md-coco-images) .date\$1captured de una imagen de la lista de imágenes COCO. Etiquetas personalizadas de Amazon Rekognition espera que el formato de `creation-date` sea *Y-M-DTH:M:S*.
#### job-name
El nombre del trabajo que prefiera.
# El formato del conjunto de datos COCO
Un conjunto de datos COCO consta de cinco secciones de información que aportan información para todo el conjunto de datos. El formato de un conjunto de datos de detección de objetos COCO viene documentado en [Formato de datos COCO](http://cocodataset.org/#format-data).
+ info: información general sobre el conjunto de datos.
+ licenses: información de las licencias de imágenes del conjunto de datos.
+ [images](#md-coco-images): lista de imágenes del conjunto de datos.
+ [annotations](#md-coco-annotations): lista de anotaciones (incluidos los cuadros delimitadores) que están presentes en todas las imágenes del conjunto de datos.
+ [categories](#md-coco-categories): lista de categorías de etiquetas.
Para crear un manifiesto de etiquetas personalizadas, utilice las listas `images`, `annotations` y `categories` del archivo de manifiesto COCO. Las demás secciones (`info`, `licences`) no son obligatorias. A continuación se muestra un ejemplo de un archivo de manifiesto 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"}
]
}
```
## images list
Las imágenes a las que hace referencia un conjunto de datos COCO figuran en la matriz de imágenes. Cada objeto de imagen contiene información sobre la imagen, como el nombre de archivo de la imagen. En el siguiente objeto de imagen de ejemplo, fíjese en la siguiente información y los campos necesarios para crear un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition.
+ `id`: (Obligatorio) Un identificador único para la imagen. El campo `id` se asigna al campo `id` de la matriz de anotaciones (donde se almacena la información del cuadro delimitador).
+ `license`: (No obligatorio) Se asigna a la matriz de licencias.
+ `coco_url`: (Opcional) La ubicación de la imagen.
+ `flickr_url`: (No obligatorio) La ubicación de la imagen en Flickr.
+ `width`: (Obligatorio) El ancho de la imagen.
+ `height`: (Obligatorio) La altura de la imagen.
+ `file_name`: (Obligatorio) El nombre del archivo de imagen. En este ejemplo, `file_name` y `id` coinciden, pero esto no es un requisito para los conjuntos de datos COCO.
+ `date_captured`: (Obligatorio) La fecha y la hora en que se capturó la imagen.
```
{
"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"
}
```
## lista de anotaciones (cuadros delimitadores)
La información de los cuadros delimitadores de todos los objetos en todas las imágenes se almacena en la lista de anotaciones. Un único objeto de anotación contiene la información del cuadro delimitador de un único objeto y la etiqueta del objeto en una imagen. Hay un objeto de anotación por cada instancia de un objeto en una imagen.
En el siguiente ejemplo, fíjese en la siguiente información y los campos necesarios para crear un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition.
+ `id`: (No obligatorio) El identificador de la anotación.
+ `image_id`: (Obligatorio) Corresponde a la imagen `id` en la matriz de imágenes.
+ `category_id`: (Obligatorio) El identificador de la etiqueta que identifica el objeto dentro de un cuadro delimitador. Se asigna al campo `id` de la matriz de categorías.
+ `iscrowd`: (No obligatorio) Señala si la imagen tiene muchos objetos.
+ `segmentation`: (No obligatorio) Información de segmentación de los objetos de una imagen. Etiquetas personalizadas de Amazon Rekognition no admite la segmentación.
+ `area`: (No obligatorio) El área de la anotación.
+ `bbox`: (Obligatorio) Incluye las coordenadas, en píxeles, de un cuadro delimitador alrededor de un objeto de la imagen.
```
{
"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]
}
```
## lista de categorías
La información de las etiquetas se almacena en la matriz de categorías. En el siguiente objeto de categoría de ejemplo, fíjese en la siguiente información y los campos necesarios para crear un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition.
+ `supercategory`: (No obligatorio) La categoría principal de una etiqueta.
+ `id`: (Obligatorio) El identificador de la etiqueta. El campo `id` se asigna al campo `category_id` de un objeto `annotation`. En el siguiente ejemplo, el identificador de un echo dot es 2.
+ `name`: (Obligatorio) El nombre de la etiqueta.
```
{"supercategory": "speaker","id": 2,"name": "echo dot"}
```
# Transformación de un conjunto de datos COCO
Use el siguiente ejemplo de Python para transformar la información de un cuadro delimitador de un conjunto de datos con formato COCO en un archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition. El código carga el archivo de manifiesto creado en el bucket de Amazon S3. El código también incluye un comando de AWS CLI que puede utilizar para cargar las imágenes.
**Cómo transformar un conjunto de datos COCO (SDK)**
1. Si aún no lo ha hecho:
1. Asegúrese de que tiene los permisos de `AmazonS3FullAccess`. Para obtener más información, consulte [Configuración de permisos de SDK](su-sdk-permissions.md).
1. Instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 4: Configure y AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Usa el siguiente código de Python para transformar un conjunto de datos COCO. Defina los siguientes valores.
+ `s3_bucket`: el nombre del bucket de S3 en el que desea almacenar las imágenes y el archivo de manifiesto de Etiquetas personalizadas de Amazon Rekognition.
+ `s3_key_path_images`: la ruta en la que desea colocar las imágenes dentro del bucket de S3 (`s3_bucket`).
+ `s3_key_path_manifest_file`: la ruta en la que desea colocar el archivo de manifiesto de Etiquetas personalizadas dentro del bucket de S3 (`s3_bucket`).
+ `local_path`: la ruta local donde el ejemplo abre el conjunto de datos COCO de entrada y también guarda el nuevo archivo de manifiesto de Etiquetas personalizadas.
+ `local_images_path`: la ruta local de las imágenes que quiera usar para el entrenamiento.
+ `coco_manifest`: el nombre de archivo del conjunto de datos COCO de entrada.
+ `cl_manifest_file`: el nombre del archivo de manifiesto creado en el ejemplo. El archivo se guarda en la ubicación indicada por `local_path`. Por convención, el archivo tiene la extensión `.manifest`, pero no es obligatoria.
+ `job_name`: el nombre para el trabajo de Etiquetas personalizadas.
```
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. Ejecute el código.
1. En el resultado del programa, anote el comando `s3 sync`. Lo necesitará en el siguiente paso.
1. En el símbolo del sistema, ejecute el comando `s3 sync`. Las imágenes se cargan en el bucket de S3. Si el comando falla durante la carga, ejecútelo de nuevo hasta que las imágenes locales se sincronicen con el bucket de S3.
1. En el resultado del programa, anote la ruta URL de S3 correspondiente al archivo de manifiesto. Lo necesitará en el siguiente paso.
1. Siga las instrucciones que aparecen en [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para crear un conjunto de datos con el archivo de manifiesto cargado. En el paso 8, en la **ubicación del archivo de manifiesto**, introduzca la URL de Amazon S3 que haya anotado en el paso anterior. Si utiliza el AWS SDK, consulte [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Transformación de los archivos de manifiesto de SageMaker AI Ground Truth con múltiples etiquetas
En este tema se muestra cómo transformar un archivo de manifiesto de Amazon SageMaker AI Ground Truth con varias etiquetas en un archivo de manifiesto con formato Amazon Rekognition Custom Labels.
SageMaker Los archivos de manifiesto de AI Ground Truth para trabajos con varias etiquetas tienen un formato diferente al de los archivos de manifiesto con formato Amazon Rekognition Custom Labels. La clasificación de etiquetas múltiples consiste en clasificar una imagen en un conjunto de clases, aunque puede pertenecer a varias clases a la vez. En este caso, es posible que la imagen tenga varias etiquetas (etiquetas múltiples), como *fútbol* y *pelota*.
Para obtener información sobre los trabajos de SageMaker AI Ground Truth con múltiples etiquetas, consulte [Clasificación de imágenes (etiquetas múltiples)](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html). Para obtener información sobre los archivos de manifiesto de etiquetas múltiples de Etiquetas personalizadas de Amazon Rekognition, consulte [Cómo agregar varias etiquetas de imagen a una imagen](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels).
## Obtener el archivo de manifiesto para un trabajo de SageMaker AI Ground Truth
El siguiente procedimiento muestra cómo obtener el archivo de manifiesto de salida (`output.manifest`) para un trabajo de Amazon SageMaker AI Ground Truth. Usará `output.manifest` como entrada en el procedimiento siguiente.
**Para descargar un archivo de manifiesto de trabajo de SageMaker AI Ground Truth**
1. Abra la [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. En el panel de navegación, elija **Ground Truth** y luego **Trabajos de etiquetado**.
1. Elija el trabajo de etiquetado que contenga el archivo de manifiesto que desee usar.
1. En la página de detalles, elija el enlace situado debajo de la **ubicación del conjunto de datos final**. Se abrirá la consola de Amazon S3 en la ubicación del conjunto de datos.
1. Elija `Manifests`, `output` y luego `output.manifest`.
1. Elija **Acciones de objeto** y después **Descargar** para descargar el archivo de manifiesto.
## Transformar un archivo de manifiesto de SageMaker IA con varias etiquetas
El siguiente procedimiento crea un archivo de manifiesto Amazon Rekognition Custom Labels con formato de etiquetas múltiples a partir de un archivo de manifiesto AI con formato multietiqueta existente. SageMaker GroundTruth
**nota**
Para ejecutar el código, necesita Python, versión 3 o superior.
**Para transformar un archivo de manifiesto de IA con varias etiquetas SageMaker**
1. Ejecute el siguiente código de Python. Indique el nombre del archivo de manifiesto que haya creado en [Obtener el archivo de manifiesto para un trabajo de SageMaker AI Ground Truth](#md-get-gt-manifest) como argumento de línea de comandos.
```
# 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. Anote el nombre del nuevo archivo de manifiesto que aparece en el script. Lo usará en el siguiente paso.
1. [Cargue los archivos de manifiesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) en el bucket de Amazon S3 que desee utilizar para almacenar el archivo de manifiesto.
**nota**
Asegúrese de que Etiquetas personalizadas de Amazon Rekognition tenga acceso al bucket de Amazon S3 al que se hace referencia en el campo `source-ref` de las líneas JSON del archivo de manifiesto. Para obtener más información, consulte [Acceso a buckets de Amazon S3 externos](su-console-policy.md#su-external-buckets). Si el trabajo en Ground Truth almacena imágenes en el bucket de consola de Etiquetas personalizadas de Amazon Rekognition, no necesitará agregar permisos.
1. Siga las instrucciones que aparecen en [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para crear un conjunto de datos con el archivo de manifiesto cargado. En el paso 8, en la **ubicación del archivo de manifiesto**, introduzca la URL de Amazon S3 de la ubicación que haya anotado en el paso anterior. Si utiliza el AWS SDK, consulte [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Creación de un archivo de manifiesto a partir de un archivo CSV
Este script de Python de ejemplo facilita la creación de un archivo de manifiesto mediante el uso de un archivo de valores separados por comas (CSV) para etiquetar las imágenes. Usted crea el archivo CSV. El archivo de manifiesto se puede usar para la [clasificación de imágenes de etiquetas múltiples](getting-started.md#gs-multi-label-image-classification-example) o [Clasificación de imágenes de etiquetas múltiples](getting-started.md#gs-multi-label-image-classification-example). Para obtener más información, consulte [Buscar objetos, escenas y conceptos](understanding-custom-labels.md#tm-classification).
**nota**
Este script no crea un archivo de manifiesto adecuado para buscar [ubicaciones de objetos](understanding-custom-labels.md#tm-object-localization) o [ubicaciones de marcas](understanding-custom-labels.md#tm-brand-detection-localization).
El archivo de manifiesto describe las imágenes utilizadas para entrenar un modelo. Por ejemplo, las ubicaciones de las imágenes y las etiquetas asignadas a las imágenes. Un archivo de manifiesto se compone de una o varias líneas JSON. Cada línea JSON describe una sola imagen. Para obtener más información, consulte [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md).
Un archivo CSV representa datos tabulares en varias filas de un archivo de texto. Los campos de las filas están separados por comas. Para obtener más información, consulte [valores separados por comas](https://en.wikipedia.org/wiki/Comma-separated_values). En este script, cada fila del archivo CSV representa una sola imagen y se asigna a una línea JSON del archivo de manifiesto. Para crear el archivo CSV de un archivo de manifiesto que admita la [clasificación de imágenes de etiquetas múltiples](getting-started.md#gs-multi-label-image-classification-example), agregue una o varias etiquetas de imagen a cada fila. Para crear un archivo de manifiesto adecuado para [Clasificación de imágenes](getting-started.md#gs-image-classification-example), agregue una sola etiqueta de imagen a cada fila.
Por ejemplo, el siguiente archivo CSV describe las imágenes del proyecto [Clasificación de imágenes de etiquetas múltiples](getting-started.md#gs-multi-label-image-classification-example) (flores) de *Introducción*.
```
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
```
El script genera líneas JSON para cada fila. Por ejemplo, la siguiente es la línea JSON de la primera fila (`camellia1.jpg,camellia,with_leaves`).
```
{"source-ref": "s3://bucket/flowers/train/camellia1.jpg","camellia": 1,"camellia-metadata":{"confidence": 1,"job-name": "labeling-job/camellia","class-name": "camellia","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"},"with_leaves": 1,"with_leaves-metadata":{"confidence": 1,"job-name": "labeling-job/with_leaves","class-name": "with_leaves","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"}}
```
En el CSV de ejemplo, la ruta de Amazon S3 de la imagen no está presente. Si el archivo CSV no incluye la ruta de Amazon S3 de las imágenes, utilice el argumento `--s3_path` de la línea de comandos para indicar la ruta de Amazon S3 correspondiente a la imagen.
El script registra la primera entrada de cada imagen en un archivo CSV de imágenes deduplicadas. El archivo CSV de imágenes deduplicadas contiene una sola instancia por cada imagen que se encuentra en el archivo CSV de entrada. Las demás apariciones de una imagen en el archivo CSV de entrada se registra en un archivo CSV de imágenes duplicadas. Si el script encuentra imágenes duplicadas, revise el archivo CSV de imágenes duplicadas y actualice el archivo CSV de imágenes deduplicadas según sea necesario. Vuelva a ejecutar el script con el archivo deduplicado. Si no se encuentra ningún duplicado en el archivo CSV de entrada, el script elimina el archivo CSV de la imagen deduplicada y la imagen duplicada CSVfile, ya que están vacíos.
En este procedimiento, se crea el archivo CSV y se ejecuta el script de Python para crear el archivo de manifiesto.
**Cómo crear un archivo de manifiesto a partir de un archivo CSV**
1. Cree un archivo CSV con los siguientes campos en cada fila (una fila por imagen). No añadas una fila de encabezado al archivo CSV.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/ex-csv-manifest.html)
Por ejemplo, `camellia1.jpg,camellia,with_leaves` o `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves`
1. Guarde el archivo CSV.
1. Ejecute el siguiente script de Python. Proporcione los siguientes argumentos:
+ `csv_file`: el archivo CSV creado en el paso 5.
+ `manifest_file`: El nombre del archivo de manifiesto que desea crear.
+ (Opcional)`--s3_path s3://path_to_folder/`: la ruta de Amazon S3 que se quiera agregar de los archivos de imagen (campo 1). Use `--s3_path` si las imágenes del campo 1 aún no contienen una ruta de S3.
```
# 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. Si tiene pensado usar un conjunto de datos de prueba, repita los pasos del 1 al 3 para crear un archivo de manifiesto para su conjunto de datos de prueba.
1. Si es necesario, copie las imágenes en la ruta del bucket de Amazon S3 que haya indicado en la columna 1 del archivo CSV (o que haya indicado en la línea de comandos `--s3_path`). Puede utilizar el siguiente comando de AWS S3.
```
aws s3 cp --recursive your-local-folder s3://your-target-S3-location
```
1. [Cargue los archivos de manifiesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) en el bucket de Amazon S3 que desee utilizar para almacenar el archivo de manifiesto.
**nota**
Asegúrese de que Etiquetas personalizadas de Amazon Rekognition tenga acceso al bucket de Amazon S3 al que se hace referencia en el campo `source-ref` de las líneas JSON del archivo de manifiesto. Para obtener más información, consulte [Acceso a buckets de Amazon S3 externos](su-console-policy.md#su-external-buckets). Si el trabajo en Ground Truth almacena imágenes en el bucket de consola de Etiquetas personalizadas de Amazon Rekognition, no necesitará agregar permisos.
1. Siga las instrucciones que aparecen en [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para crear un conjunto de datos con el archivo de manifiesto cargado. En el paso 8, en la **ubicación del archivo de manifiesto**, introduzca la URL de Amazon S3 de la ubicación que haya anotado en el paso anterior. Si utiliza el AWS SDK, consulte [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Copia de contenido de un conjunto de datos existente
Si ya ha creado un conjunto de datos, puede copiar su contenido en un conjunto de datos nuevo. Para crear un conjunto de datos a partir de un conjunto de datos existente con el AWS SDK, consulte. [Creación de un conjunto de datos mediante un conjunto de datos existente (SDK)](md-create-dataset-existing-dataset-sdk.md)
**Cómo crear un conjunto de datos mediante un conjunto de datos existente de Etiquetas personalizadas de Amazon Rekognition existente (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto al que desee añadir el conjunto de datos. Se abrirá la página de detalles del proyecto.
1. Elija **Crear conjunto de datos**. Se abrirá la página **Crear conjunto de datos**.
1. En **Configuración inicial**, seleccione **Empezar con un único conjunto de datos** o **Empezar con un conjunto de datos de entrenamiento**. Para crear un modelo de mayor calidad, le recomendamos empezar con conjuntos de datos de entrenamiento y de prueba independientes.
------
#### [ Single dataset ]
1. En la sección **Detalles del conjunto de datos de entrenamiento**, seleccione **Copiar un conjunto de datos de Etiquetas personalizadas de Amazon Rekognition existente**.
1. En la sección **Detalles del conjunto de datos de entrenamiento**, en el cuadro de edición **Conjunto de datos**, escriba o seleccione el nombre del conjunto de datos que desee copiar.
1. Elija **Crear conjunto de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
------
#### [ Separate training and test datasets ]
1. En la sección **Detalles del conjunto de datos de entrenamiento**, seleccione **Copiar un conjunto de datos de Etiquetas personalizadas de Amazon Rekognition existente**.
1. En la sección **Detalles del conjunto de datos de entrenamiento**, en el cuadro de edición **Conjunto de datos**, escriba o seleccione el nombre del conjunto de datos que desee copiar.
1. En la sección **Detalles del conjunto de datos de prueba**, seleccione **Copiar un conjunto de datos de Etiquetas personalizadas de Amazon Rekognition existente**.
1. En la sección **Detalles del conjunto de datos de prueba**, en el cuadro de edición **Conjunto de datos**, escriba o seleccione el nombre del conjunto de datos que desee copiar.
**nota**
Los conjuntos de datos de entrenamiento y de prueba pueden tener diferentes fuentes de imágenes.
1. Elija **Crear conjuntos de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
------
1. Si necesita agregar o cambiar etiquetas, consulte [Etiquetado de imágenes](md-labeling-images.md).
1. Siga los pasos que se indican en [Entrenamiento de un modelo (consola)](training-model.md#tm-console) para entrenar el modelo.
# Etiquetado de imágenes
Una etiqueta identifica un objeto, una escena, un concepto o un cuadro delimitador alrededor del objeto de una imagen. Por ejemplo, si el conjunto de datos contiene imágenes de perros, puede agregar etiquetas de razas de perros.
Después de importar las imágenes a un conjunto de datos, es posible que tenga que agregar etiquetas a las imágenes o corregir las imágenes mal etiquetadas. Por ejemplo, las imágenes importadas de un ordenador local no vienen etiquetadas. Utilice la galería de conjuntos de datos para agregar nuevas etiquetas al conjunto de datos y asignar etiquetas y cuadros delimitadores a las imágenes del conjunto de datos.
La forma en que etiquete las imágenes en sus conjuntos de datos determina el tipo de modelo que entrena Etiquetas personalizadas de Amazon Rekognition. Para obtener más información, consulte [Finalidad de los conjuntos de datos](md-dataset-purpose.md).
**Topics**
+ [Administración de etiquetas](md-labels.md)
+ [Asignación de etiquetas de imagen a una imagen](md-assign-image-level-labels.md)
+ [Etiquetado de objetos con cuadros delimitadores](md-localize-objects.md)
# Administración de etiquetas
Puede gestionar las etiquetas mediante la consola de Etiquetas personalizadas de Amazon Rekognition. No hay una API específica para administrar las etiquetas: las etiquetas se agregan al conjunto de datos cuando se crea el conjunto de datos con `CreateDataset` o cuando se agregan más imágenes al conjunto de datos con `UpdateDatasetEntries`.
**Topics**
+ [Administración de etiquetas (consola)](#md-labels-console)
+ [Administración de etiquetas (SDK)](#md-labels-sdk)
## Administración de etiquetas (consola)
Puede utilizar la consola de Etiquetas personalizadas de Amazon Rekognition para agregar, cambiar o eliminar etiquetas. Para agregar una etiqueta a un conjunto de datos, puede agregar una etiqueta nueva que cree o importar etiquetas de un conjunto de datos existente en Rekognition.
**Topics**
+ [Agregar etiquetas nuevas (consola)](#md-add-new-labels)
+ [Cambiar y eliminar etiquetas (consola)](#md-edit-labels-after-adding)
### Agregar etiquetas nuevas (consola)
Puede indicar nuevas etiquetas que desee agregar al conjunto de datos.
#### Agregar etiquetas mediante la ventana de edición
**Cómo agregar una nueva etiqueta (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto que desee usar. Se abrirá la página de detalles del proyecto.
1. Si quiere agregar etiquetas al conjunto de datos de entrenamiento, elija la pestaña **Entrenamiento**. Si no, seleccione la pestaña **Prueba** para agregar etiquetas al conjunto de datos de prueba.
1. Elija **Comenzar a etiquetar** para activar el modo de etiquetado.
1. En la sección **Etiquetas** de la galería de conjuntos de datos, elija **Administrar etiquetas** para abrir el cuadro de diálogo **Administrar etiquetas**.
1. En el cuadro de edición, introduzca un nombre de etiqueta nuevo.
1. Elija **Agregar nueva etiqueta**.
1. Repita los pasos 9 y 10 hasta que haya creado todas las etiquetas que necesite.
1. Elija **Guardar** para guardar las etiquetas que haya añadido.
### Cambiar y eliminar etiquetas (consola)
Puede cambiar el nombre de las etiquetas o eliminarlas después de agregarlas a un conjunto de datos. Solo puede eliminar las etiquetas que no estén asignadas a ninguna imagen.
**Cómo cambiar el nombre de una etiqueta existente o eliminarla (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto que desee usar. Se abrirá la página de detalles del proyecto.
1. Si quiere cambiar o eliminar etiquetas en el conjunto de datos de entrenamiento, elija la pestaña **Entrenamiento**. De lo contrario, seleccione la pestaña **Prueba** para cambiar o eliminar etiquetas en el conjunto de datos de prueba.
1. Elija **Comenzar a etiquetar** para activar el modo de etiquetado.
1. En la sección **Etiquetas** de la galería de conjuntos de datos, elija **Administrar etiquetas** para abrir el cuadro de diálogo **Administrar etiquetas**.
1. Elija la etiqueta que desee editar o eliminar.
![\[El cuadro de diálogo Administrar etiquetas muestra un campo de texto para añadir una etiqueta nueva y una etiqueta existente denominada “probar” con opciones para guardar o cancelar los cambios.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/change-delete-label.jpg)
1. Si selecciona el icono de eliminación (X), la etiqueta se quitará de la lista.
1. Si quiere cambiar la etiqueta, seleccione el icono de edición (lápiz y bloc de notas) e introduzca un nombre nuevo para la etiqueta en el cuadro de edición.
1. Elija **Guardar** para guardar los cambios.
## Administración de etiquetas (SDK)
No hay una API única que administre las etiquetas de los conjuntos de datos. Si crea un conjunto de datos con `CreateDataset`, las etiquetas que se encuentren en el archivo de manifiesto o el conjunto de datos copiado, se creará el grupo inicial de etiquetas. Si agrega más imágenes con la API de `UpdateDatasetEntries`, las nuevas etiquetas que se encuentren en las entradas se agregarán al conjunto de datos. Para obtener más información, consulte [Agregar más imágenes (SDK)](md-add-images.md#md-add-images-sdk). Para eliminar etiquetas de un conjunto de datos, es necesario eliminar todas las anotaciones de etiquetas del conjunto de datos.
**Cómo eliminar etiquetas de un conjunto de datos**
1. Llame a `ListDatasetEntries` para obtener las entradas del conjunto de datos. Para ver el código de ejemplo, consulte [Listado de entradas del conjunto de datos (SDK)](md-listing-dataset-entries-sdk.md).
1. En el archivo, elimine cualquier anotación en la etiqueta. Para obtener más información, consulte [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md) y [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
1. Use el archivo para actualizar el conjunto de datos con la API de `UpdateDatasetEntries`. Para obtener más información, consulte [Agregar más imágenes (SDK)](md-add-images.md#md-add-images-sdk).
# Asignación de etiquetas de imagen a una imagen
Las etiquetas de imagen se utilizan para entrenar modelos que clasifican las imágenes en categorías. Una etiqueta de imagen indica que una imagen contiene un objeto, una escena o un concepto. Por ejemplo, en la siguiente imagen se ve un río. Si el modelo clasifica las imágenes como imágenes que contienen ríos, se debe agregar la etiqueta de imagen *río*. Para obtener más información, consulte [Finalidad de los conjuntos de datos](md-dataset-purpose.md).
![\[Lago que refleja montañas y nubes en aguas tranquilas al atardecer o al amanecer.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/pateros.jpg)
Un conjunto de datos que contiene etiquetas de imagen necesita tener definidas al menos dos etiquetas. Cada imagen necesita al menos una etiqueta asignada que identifique el objeto, la escena o el concepto de la imagen.
**Cómo asignar etiquetas de imagen a una imagen (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto que desee usar. Se abrirá la página de detalles del proyecto.
1. En el panel de navegación de la izquierda, elija **Conjunto de datos**.
1. Si quiere agregar etiquetas al conjunto de datos de entrenamiento, elija la pestaña **Entrenamiento**. Si no, seleccione la pestaña **Prueba** para agregar etiquetas al conjunto de datos de prueba.
1. Elija **Comenzar a etiquetar** para activar el modo de etiquetado.
1. En la galería de imágenes, seleccione una o varias imágenes a las que quiera agregar etiquetas. Solo puede seleccionar imágenes en una sola página a la vez. Cómo seleccionar una serie contigua de imágenes en una página:
1. Seleccione la primera imagen del rango.
1. Deje pulsada la tecla Mayús.
1. Seleccione la última imagen del rango. Se seleccionarán también las imágenes entre la primera y la segunda imagen.
1. Suelte la tecla Mayús.
1. Elija **Asignar etiquetas de imagen**.
1. En el cuadro de diálogo **Asignar etiqueta de imagen a las imágenes seleccionadas**, seleccione la etiqueta que desee asignar a la imagen o imágenes.
1. Elija **Asignar** para asignar la etiqueta a la imagen.
1. Repita el proceso de etiquetado hasta que todas las imágenes estén anotadas con las etiquetas necesarias.
1. Elija **Guardar cambios** para guardar los cambios.
## Asignación de etiquetas de imagen (SDK)
Puede usar la API de `UpdateDatasetEntries` para agregar o actualizar las etiquetas de imagen que estén asignadas a una imagen. `UpdateDatasetEntries` toma una o varias líneas JSON. Cada línea JSON representa una sola imagen. En el caso de una imagen con una etiqueta de imagen, la línea JSON tiene un aspecto similar al siguiente.
```
{"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"}}
```
El campo `source-ref` indica la ubicación de la imagen. La línea JSON también incluye las etiquetas imagen asignadas a la imagen. Para obtener más información, consulte [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md).
**Cómo asignar etiquetas de imagen a una imagen**
1. Obtenga la línea get JSON para la imagen existente con `ListDatasetEntries`. En el campo `source-ref`, indique la ubicación de la imagen a la que desea asignar la etiqueta. Para obtener más información, consulte [Listado de entradas del conjunto de datos (SDK)](md-listing-dataset-entries-sdk.md).
1. Actualice la línea JSON devuelta en el paso anterior con la información que se encuentra en [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md).
1. Llame a `UpdateDatasetEntries` para actualizar la imagen. Para obtener más información, consulte [Agregar más imágenes a un conjunto de datos](md-add-images.md).
# Etiquetado de objetos con cuadros delimitadores
Si desea que el modelo detecte la ubicación de objetos dentro de una imagen, debe identificar qué es el objeto y en qué parte de la imagen se encuentra. Un cuadro delimitador es un cuadro que aísla un objeto de una imagen. Los cuadros delimitadores se utilizan para entrenar un modelo para que detecte distintos objetos en la misma imagen. El objeto se identifica asignando una etiqueta al cuadro delimitador.
**nota**
Si está entrenando un modelo para que busque objetos, escenas y conceptos con etiquetas de imagen, no es necesario realizar este paso.
Por ejemplo, si quiere entrenar un modelo que detecte dispositivos Amazon Echo Dot, dibuje un recuadro delimitador alrededor de cada Echo Dot en una imagen y asigna una etiqueta denominada *Echo Dot* al cuadro delimitador. En la siguiente imagen se muestra un cuadro delimitador alrededor de un Amazon Echo Dot. En la imagen también aparece un Amazon Echo sin un cuadro delimitador.
![\[Dispositivos Amazon Echo Dot y Echo con un cuadro delimitador alrededor de Echo Dot.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/dot.jpg)
## Localización de objetos con cuadros delimitadores (consola)
En este procedimiento, utilizará la consola para dibujar cuadros delimitadores alrededor de los objetos de las imágenes. Puede identificar objetos dentro de la imagen asignando etiquetas al cuadro delimitador.
**nota**
No es posible usar el navegador Safari para agregar cuadros delimitadores a las imágenes. Para ver los navegadores compatibles, consulte [Configuración de Etiquetas personalizadas de Amazon Rekognition](setting-up.md).
Para poder agregar cuadros delimitadores, debe agregar al menos una etiqueta al conjunto de datos. Para obtener más información, consulte [Agregar etiquetas nuevas (consola)](md-labels.md#md-add-new-labels).
****
**Cómo agregar cuadros delimitadores a las imágenes (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto que desee usar. Se abrirá la página de detalles del proyecto.
1. En la página de detalles del proyecto, elija **Etiquetar imágenes**.
1. Si quiere agregar cuadros delimitadores a las imágenes del conjunto de datos de entrenamiento, elija la pestaña **Entrenamiento**. Si no, seleccione la pestaña **Prueba** para agregar cuadros delimitadores a las imágenes del conjunto de datos de prueba.
1. Elija **Comenzar a etiquetar** para activar el modo de etiquetado.
1. En la galería de imágenes, elija a las que desee agregar cuadros delimitadores.
1. Seleccione **Dibujar cuadro delimitador**. Se verán una serie de consejos antes de que aparezca el editor de cuadros delimitadores.
1. En el panel **Etiquetas** de la derecha, seleccione la etiqueta que desee asignar a un cuadro delimitador.
1. En la herramienta de dibujo, coloque el puntero en el área superior izquierda del objeto deseado.
1. Pulse el botón izquierdo del ratón y dibuje un cuadro alrededor del objeto. Dibuje el cuadro delimitador lo más cerca posible del objeto.
1. Suelte el botón del ratón. El cuadro delimitador aparecerá resaltado.
1. Elija **Siguiente** si tiene más imágenes que etiquetar. Si ya ha terminado, seleccione **Listo** para terminar de etiquetar.
![\[Interfaz de usuario para dibujar un cuadro delimitador alrededor de una imagen; la imagen son los altavoces inteligentes Amazon Echo y Echo Dot sobre una superficie de madera.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/draw-bounding-box.png)
1. Repita los pasos del 1 al 7 hasta que haya creado un cuadro delimitador en cada imagen que contenga objetos.
1. Elija **Guardar cambios** para guardar los cambios.
1. Seleccione **Salir** para salir del modo de etiquetado.
## Localización de objetos con cuadros delimitadores (SDK)
Puede usar la API de `UpdateDatasetEntries` para agregar o actualizar la información de la ubicación de objetos de una imagen. `UpdateDatasetEntries` toma una o varias líneas JSON. Cada línea JSON representa una sola imagen. En la localización de objetos, una línea JSON tiene un aspecto similar al siguiente.
```
{"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"}}
```
El campo `source-ref` indica la ubicación de la imagen. La línea JSON también incluye cuadros delimitadores etiquetados por cada objeto de la imagen. Para obtener más información, consulte [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
**Cómo asignar cuadros delimitadores a una imagen**
1. Obtenga la línea get JSON para la imagen existente con `ListDatasetEntries`. En el campo `source-ref`, indique la ubicación de la imagen a la que desea asignar la etiqueta de imagen. Para obtener más información, consulte [Listado de entradas del conjunto de datos (SDK)](md-listing-dataset-entries-sdk.md).
1. Actualice la línea JSON devuelta en el paso anterior con la información que se encuentra en [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
1. Llame a `UpdateDatasetEntries` para actualizar la imagen. Para obtener más información, consulte [Agregar más imágenes a un conjunto de datos](md-add-images.md).
# Depuración de errores de conjuntos de datos
Durante la creación del conjunto de datos, se pueden producir dos tipos de errores: *errores terminales* y *errores no terminales*. Los errores terminales pueden detener la creación o actualización del conjunto de datos. Los errores no terminales no detienen la creación o actualización del conjunto de datos.
**Topics**
+ [Depuración de errores terminales de conjunto de datos](debugging-datasets-terminal-errors.md)
+ [Depuración de errores no terminales de conjunto de datos](debugging-datasets-non-terminal-errors.md)
# Depuración de errores terminales de conjunto de datos
Existen dos tipos de errores terminales: errores de archivo que provocan un error en la creación del conjunto de datos y errores de contenido que Etiquetas personalizadas de Amazon Rekognition elimina del conjunto de datos. No se pueden crear conjuntos de datos si hay demasiados errores de contenido.
**Topics**
+ [Errores de archivo terminales](#debugging-datasets-terminal-file-errors)
+ [Errores terminales de contenido](#debugging-datasets-terminal-content-errors)
## Errores de archivo terminales
Los siguientes son errores de archivo. Puede obtener información sobre los errores de archivos llamando a `DescribeDataset` y comprobando los campos `Status` y `StatusMessage`. Para ver el código de ejemplo, consulte [Descripción de un conjunto de datos (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\$1INSUFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1DISTRIBUTE](#md-error-status-ERROR_INSUFFICIENT_IMAGES_PER_LABEL_FOR_DISTRIBUTE)
### ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT
#### Mensaje de error
The manifest file extension or contents are invalid.
El archivo de manifiesto de entrenamiento o de prueba no tiene una extensión de archivo o su contenido no es válido.
**Cómo corregir el error *ERROR\$1MANIFEST\$1INACCESSIBLE\$1OR\$1UNSUPPORTED\$1FORMAT***
+ Compruebe las siguientes causas posibles en los archivos de manifiesto de entrenamiento y de prueba.
+ El archivo de manifiesto no tiene la extensión de archivo. Por convención, la extensión del archivo es `.manifest`.
+ No se ha encontrado el bucket de Amazon S3 o la clave del archivo de manifiesto.
### ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE
#### Mensaje de error
The manifest file size exceeds the maximum supported size.
El tamaño del archivo de manifiesto de entrenamiento o de prueba (en bytes) es demasiado grande. Para obtener más información, consulte [Directrices y cuotas en Etiquetas personalizadas de Amazon Rekognition](limits.md). Un archivo de manifiesto puede tener menos de la cantidad máxima de líneas JSON y aun así superar el tamaño máximo de archivo.
No puede usar la consola de Etiquetas personalizadas de Amazon Rekognition para corregir el error *El tamaño del archivo de manifiesto supera el tamaño máximo admitido*.
**Cómo corregir el error *ERROR\$1MANIFEST\$1SIZE\$1TOO\$1LARGE***
1. Compruebe cuáles de los manifiestos de entrenamiento y de prueba superan el tamaño máximo de archivo.
1. Reduzca el número de líneas JSON demasiado grandes en los archivos de manifiesto. Para obtener más información, consulte [Creación de un archivo de manifiesto](md-create-manifest-file.md).
### ERROR\$1MANIFEST\$1ROWS\$1EXCEEDS\$1MAXIMUM
#### Mensaje de error
The manifest file has too many rows.
#### Más información
El número de líneas JSON (número de imágenes) del archivo de manifiesto supera el límite permitido. El límite es diferente en los modelos de imágenes y los modelos de ubicación de objetos. Para obtener más información, consulte [Directrices y cuotas en Etiquetas personalizadas de Amazon Rekognition](limits.md).
Los errores en las líneas JSON se validan hasta que el número de líneas JSON alcanza el límite de `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`.
No es posible usar la consola de Etiquetas personalizadas de Amazon Rekognition para subsanar el error `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`.
**Cómo corregir `ERROR_MANIFEST_ROWS_EXCEEDS_MAXIMUM`**
+ Reduzca el número de líneas JSON en el manifiesto. Para obtener más información, consulte [Creación de un archivo de manifiesto](md-create-manifest-file.md).
### ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET
#### Mensaje de error
The S3 bucket permissions are incorrect.
Etiquetas personalizadas de Amazon Rekognition no tiene permisos para uno o varios de los buckets que contienen los archivos de manifiesto de entrenamiento y de prueba.
No es posible usar la consola de Etiquetas personalizadas de Amazon Rekognition para subsanar este error.
**Cómo corregir el error *ERROR\$1INVALID\$1PERMISSIONS\$1MANIFEST\$1S3\$1BUCKET***
+ Compruebe los permisos de los buckets que contengan los manifiestos de entrenamiento y de prueba. Para obtener más información, consulte [Paso 2: Configurar los permisos de la consola de Etiquetas personalizadas de Amazon Rekognition](su-console-policy.md).
### ERROR\$1TOO\$1MANY\$1RECORDS\$1IN\$1ERROR
#### Mensaje de error
The manifest file has too many terminal errors.
**Cómo corregir `ERROR_TOO_MANY_RECORDS_IN_ERROR`**
+ Reduzca el número de líneas JSON (imágenes) con errores terminales en el contenido. Para obtener más información, consulte [Errores terminales de contenido del manifiesto](tm-debugging-aggregate-errors.md).
No es posible usar la consola de Etiquetas personalizadas de Amazon Rekognition para subsanar este error.
### ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS
#### Mensaje de error
The manifest file has too many labels.
##### Más información
El número de etiquetas únicas en el manifiesto (conjunto de datos) supera el límite permitido. Si el conjunto de datos de entrenamiento se divide para crear un conjunto de datos de prueba, el número de etiquetas se determinará después de la división.
**Cómo corregir ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS (consola)**
+ Elimine las etiquetas del conjunto de datos. Para obtener más información, consulte [Administración de etiquetas](md-labels.md). Las etiquetas se eliminan automáticamente de las imágenes y los cuadros delimitadores en el conjunto de datos.
**Cómo corregir ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS (línea JSON)**
+ Manifiestos con líneas JSON de imagen: si la imagen tiene una sola etiqueta, elimine las líneas JSON de las imágenes que utilicen la etiqueta deseada. Si la línea JSON contiene varias etiquetas, elimine solo el objeto JSON de la etiqueta deseada. Para obtener más información, consulte [Cómo agregar varias etiquetas de imagen a una imagen](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels).
Manifiestos con líneas JSON con la ubicación del objeto: elimine el cuadro delimitador y la información de etiqueta asociada a la etiqueta que desee eliminar. Haga esto en cada línea JSON que contenga la etiqueta deseada. Es necesario eliminar la etiqueta de la matriz `class-map` y los objetos correspondientes de la matriz `objects` y `annotations`. Para obtener más información, consulte [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md).
### ERROR\$1INSUFICIENT\$1IMAGES\$1PER\$1LABEL\$1FOR\$1DISTRIBUTE
#### Mensaje de error
The manifest file doesn't have enough labeled images to distribute the dataset.
La distribución del conjunto de datos se produce cuando Etiquetas personalizadas de Amazon Rekognition divide un conjunto de datos de entrenamiento para crear un conjunto de datos de prueba. También puede dividir un conjunto de datos llamando a la API de `DistributeDatasetEntries`.
**Cómo corregir el error *ERROR\$1MANIFEST\$1TOO\$1MANY\$1LABELS***
+ Agregar más imágenes etiquetadas al conjunto de datos de entrenamiento
## Errores terminales de contenido
Los siguientes son errores terminales de contenido. Al crear el conjunto de datos, las imágenes que tienen errores terminales de contenido se eliminan del conjunto de datos. El conjunto de datos se puede seguir utilizando para el entrenamiento. Si hay demasiados errores de contenido, se produce un error. dataset/update Los errores terminales de contenido relacionados con las operaciones de los conjuntos de datos no aparecen en la consola ni se devuelven de `DescribeDataset` ni ninguna otra API. Si faltan imágenes o anotaciones en los conjuntos de datos, consulte los archivos de manifiesto de los conjuntos de datos para ver si se dan los siguientes problemas:
+ La longitud de una línea JSON es demasiado larga. La longitud máxima es de 100 000 caracteres.
+ Falta el valor `source-ref` en una línea JSON.
+ El formato del valor `source-ref` en una línea JSON no es válido.
+ El contenido de una línea JSON no es válido.
+ Hay un valor en el que el campo `source-ref` aparece más de una vez. Solo se puede hacer referencia a una imagen una vez en un conjunto de datos.
Para obtener más información sobre el campo `source-ref`, consulte [Creación de un archivo de manifiesto](md-create-manifest-file.md).
# Depuración de errores no terminales de conjunto de datos
Los siguientes son errores no terminales que pueden producirse durante la creación o actualización del conjunto de datos. Estos errores pueden invalidar una línea JSON completa o invalidar las anotaciones dentro de una línea JSON. Si una línea JSON presenta un error, no se usará para el entrenamiento. Si una anotación dentro de una línea JSON contiene un error, la línea JSON se seguirá utilizando para el entrenamiento, pero sin la anotación rota. Para obtener más información sobre la líneas JSON, consulte [Creación de un archivo de manifiesto](md-create-manifest-file.md).
Puede acceder a los errores no terminales relacionados en la consola y llamando a la API de `ListDatasetEntries`. Para obtener más información, consulte [Listado de entradas del conjunto de datos (SDK)](md-listing-dataset-entries-sdk.md).
Los siguientes errores también se devuelven durante el entrenamiento. Le recomendamos que subsane estos errores antes de entrenar el modelo. Para obtener más información, consulte. [Errores no terminales de validación en líneas 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)
## Acceso a los errores no terminales
Puede usar la consola para saber qué imágenes de un conjunto de datos tienen errores no terminales. También puede llamar a la API de `ListDatasetEntries` para ver los mensajes de error. Para obtener más información, consulte [Listado de entradas del conjunto de datos (SDK)](md-listing-dataset-entries-sdk.md).
**Cómo acceder a los errores no terminales (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto que desee usar. Se abrirá la página de detalles del proyecto.
1. Si quiere ver los errores no terminales en el conjunto de datos de entrenamiento, seleccione la pestaña **Entrenamiento**. De lo contrario, elija la pestaña **Prueba** para ver los errores no terminales en el conjunto de datos de prueba.
1. En la sección **Etiquetas** de la galería de conjuntos de datos, elija **Errores**. La galería de conjuntos de datos se filtrará para que salgan solamente las imágenes con errores.
1. Seleccione **Error** debajo de cada imagen para ver el código de error. Use la información de [Errores no terminales de validación en líneas JSON](tm-debugging-json-line-errors.md) para corregir el error.
![\[El cuadro de diálogo de error muestra “ERROR_UNSUPPORTED_USE_CASE_TYPE” y “ERROR_NO_VALID_LABEL_ATTRIBUTES” en “Errores de registro de conjunto de datos”.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/customlabels-dg/images/dataset-non-terminal-error.jpg)