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.
Entrenamiento de un modelo de Etiquetas personalizadas de Amazon Rekognition
Puede entrenar un modelo a través de la consola de Etiquetas personalizadas de Amazon Rekognition o mediante la API de Etiquetas personalizadas de Amazon Rekognition. Si el entrenamiento del modelo no funciona, utilice la información incluida en Depuración de un modelo de entrenamiento con errores para hallar la causa del error.
Se le cobrará por el tiempo que se tarde en entrenar correctamente un modelo. Por lo general, el entrenamiento tarda entre 30 minutos y 24 horas en completarse. Para obtener más información, consulte Horas de entrenamiento.
Se crea una nueva versión del modelo cada vez que se entrena. Etiquetas personalizadas de Amazon Rekognition crea un nombre para el modelo que es una combinación del nombre del proyecto y la marca de tiempo de creación del modelo.
Para entrenar el modelo, Etiquetas personalizadas de Amazon Rekognition hace una copia de las imágenes de entrenamiento y de prueba de origen. De forma predeterminada, las imágenes copiadas se cifran en reposo con una clave que AWS posee y administra. También puede optar por utilizar su propia AWS KMS key. Si usa su propia clave de KMS, necesitará los siguientes permisos en la clave de KMS.
km: CreateGrant
km: DescribeKey
Para obtener más información, consulte Conceptos de AWS Key Management Service. Las imágenes de origen no se ven afectadas.
Puede utilizar el cifrado del servidor de KMS (SSE-KMS) para cifrar las imágenes de entrenamiento y de prueba del bucket de Amazon S3 antes de que las copie Etiquetas personalizadas de Amazon Rekognition. Para permitir que Amazon Rekognition Custom Labels acceda a sus imágenes AWS , su cuenta necesita los siguientes permisos en la clave de KMS.
kms: GenerateDataKey
kms:Decrypt
Para obtener más información, consulte Protección de datos mediante el cifrado del servidor con claves de KMS almacenadas en AWS Key Management Service (SSE-KMS).
Tras entrenar un modelo, puede evaluar su rendimiento y realizar mejoras. Para obtener más información, consulte Mejora de un modelo de Etiquetas personalizadas de Amazon Rekognition.
Para realizar otras tareas del modelo, como etiquetar un modelo, consulte Administración de un modelo de Etiquetas personalizadas de Amazon Rekognition.
Entrenamiento de un modelo (consola)
Puede usar la consola de Etiquetas personalizadas de Amazon Rekognition para entrenar un modelo.
El entrenamiento requiere un proyecto con un conjunto de datos de entrenamiento y un conjunto de datos de prueba. Si el proyecto no tiene un conjunto de datos de prueba, la consola de Etiquetas personalizadas de Amazon Rekognition dividirá el conjunto de datos de entrenamiento durante el entrenamiento para crear uno para su proyecto. Las imágenes elegidas son una muestra representativa y no se utilizan en el conjunto de datos de entrenamiento. Le recomendamos que divida su conjunto de datos de entrenamiento solo si no tiene un conjunto de datos de prueba alternativo que pueda usar. Al dividir un conjunto de datos de entrenamiento, se reduce la cantidad de imágenes disponibles para el entrenamiento.
Se le cobrará por el tiempo que se tarde en entrenar un modelo. Para obtener más información, consulte Horas de entrenamiento.
Cómo entrenar su modelo (consola)
Abra la consola de Amazon Rekognition en https://console.aws.amazon.com/rekognition/.
Elija Usar etiquetas personalizadas.
En el panel de navegación izquierdo, elija Proyectos.
En la página Proyectos, elija el proyecto que contiene el modelo entrenado que desee entrenar.
En la página Proyecto, elija Entrenar modelo.
(Opcional) Si quiere usar su propia clave de cifrado de AWS KMS, haga lo siguiente:
En Cifrado de datos de imagen, elija Personalizar la configuración de cifrado (avanzado).
En encryption.aws_kms_key, introduzca el nombre de recurso de Amazon (ARN) de su clave o elija una clave de AWS KMS existente. Para crear una clave nueva, elija Crear una clave de AWS IMS.
(Opcional) Si desea agregar etiquetas al modelo, haga lo siguiente:
En la sección Etiquetas, elija Agregar nueva etiqueta.
Introduzca lo siguiente:
El nombre de la clave en Key.
El valor de la clave en Valor.
Para añadir más etiquetas, repita los pasos 6a y 6b.
(Opcional) Si desea eliminar una etiqueta, elija Eliminar junto a la etiqueta que desea eliminar. Si va a eliminar una etiqueta guardada anteriormente, se eliminará al guardar los cambios.
En la página Entrenar modelo, elija Entrenar modelo. El nombre de recurso de Amazon (ARN) del proyecto se encuentra en el cuadro de edición Elegir proyecto. Si no es así, introduzca el ARN del proyecto.
En el cuadro de diálogo ¿Quiere entrenar su modelo?, escoja Entrenar modelo.
En la sección Modelos de la página del proyecto, podrá comprobar el estado actual en la columna Model Status
en la que se esté efectuando el entrenamiento. El entrenamiento de un modelo tarda un tiempo en completarse.
Una vez finalizado, elija el nombre del modelo. El entrenamiento termina cuando el estado del modelo es TRAINING_COMPLETED. Si hay algún problema con el entrenamiento, consulte Depuración de un modelo de entrenamiento con errores.
Siguiente paso: Evaluar el modelo. Para obtener más información, Mejora de un modelo de Etiquetas personalizadas de Amazon Rekognition.
Entrenamiento de un modelo (SDK)
Se entrena a un modelo llamando. CreateProjectVersion Para entrenar un modelo, se necesita la siguiente información:
Nombre: un nombre único para la versión del modelo.
ARN del proyecto: nombre de recurso de Amazon (ARN) del proyecto que administra el modelo.
Ubicación de los resultados del entrenamiento: ubicación de Amazon S3 en la que se registran los resultados. Puede usar la misma ubicación que el bucket de Amazon S3 de la consola o puede elegir una ubicación diferente. Le recomendamos que elija una ubicación diferente porque así podrá configurar permisos y evitar posibles conflictos de nombres con los resultados del entrenamiento al utilizar la consola de Etiquetas personalizadas de Amazon Rekognition.
El entrenamiento utiliza los conjuntos de datos de entrenamiento y de prueba asociados al proyecto. Para obtener más información, consulte Administración de conjuntos de datos.
Si lo desea, puede indicar los archivos de manifiesto de los conjuntos de datos de entrenamiento y de prueba que sean externos a un proyecto. Si abre la consola después de entrenar un modelo con archivos de manifiesto externos, Etiquetas personalizadas de Amazon Rekognition crea los conjuntos de datos automáticamente utilizando el último grupo de archivos de manifiesto utilizado para el entrenamiento. Ya se no podrá entrenar la versión de un modelo del proyecto si se especifican archivos de manifiesto externos. Para obtener más información, consulte CreatePrjectVersion.
La respuesta de CreateProjectVersion
es un ARN que se utiliza para identificar la versión del modelo en solicitudes posteriores. También puede usar el ARN para proteger la versión del modelo. Para obtener más información, consulte Protección de proyectos de Etiquetas personalizadas de Amazon Rekognition.
El entrenamiento de la versión de un modelo tarda un tiempo en completarse. En los ejemplos de Python y Java de este tema, se utilizan esperadores para el entrenamiento del modelo. Un esperador es un método de utilidad que sondean si se da un determinado estado. También puede conocer el estado actual del entrenamiento llamando a DescribeProjectVersions
. El entrenamiento habrá finalizado cuando el valor del campo Status
es TRAINING_COMPLETED
. Una vez terminado el entrenamiento, puede evaluar la calidad del modelo revisando los resultados de la evaluación.
Entrenamiento de un modelo (SDK)
En el siguiente ejemplo se indica cómo entrenar un modelo mediante los conjuntos de datos de entrenamiento y de prueba asociados a un proyecto.
Cómo entrenar un modelo (SDK)
-
Si aún no lo ha hecho, instale y configure los AWS CLI y los AWS SDK. Para obtener más información, consulte Paso 4: Configure los SDK y AWS CLIAWS.
Utilice el siguiente código de ejemplo para describir un proyecto.
- AWS CLI
-
En el siguiente ejemplo se ve cómo se crea un modelo. El conjunto de datos de entrenamiento se divide para crear el conjunto de datos de prueba. Sustituya lo siguiente:
-
my_project_arn
por el nombre de recurso de Amazon (ARN) del proyecto.
-
version_name
por el nombre único de la versión único que prefiera.
-
output_bucket
por el nombre del bucket de Amazon S3 en el que Etiquetas personalizadas de Amazon Rekognition guarda los resultados del entrenamiento.
-
output_folder
por el nombre de la carpeta donde se guardan los resultados del entrenamiento.
(parámetro opcional) --kms-key-id
por el identificador de la clave principal de cliente de AWS Key Management Service.
aws rekognition create-project-version \
--project-arn project_arn
\
--version-name version_name
\
--output-config '{"S3Bucket":"output_bucket
", "S3KeyPrefix":"output_folder
"}' \
--profile custom-labels-access
- Python
-
En el siguiente ejemplo se ve cómo se crea un modelo. Indique los siguientes argumentos de línea de comandos:
project_arn
: el nombre de recurso de Amazon (ARN) del proyecto.
version_name
: el nombre único de la versión del modelo que elija.
output_bucket
: el nombre del bucket de Amazon S3 en el que Etiquetas personalizadas de Amazon Rekognition guarda los resultados del entrenamiento.
output_folder
: el nombre de la carpeta donde se guardan los resultados del entrenamiento.
Si lo desea, indique los siguientes parámetros de línea de comandos para adjuntar una etiqueta al modelo:
#Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import argparse
import logging
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def train_model(rek_client, project_arn, version_name, output_bucket, output_folder, tag_key, tag_key_value):
"""
Trains an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to train a model.
:param version_name: A version for the model.
:param output_bucket: The S3 bucket that hosts training output.
:param output_folder: The path for the training output within output_bucket
:param tag_key: The name of a tag to attach to the model. Pass None to exclude
:param tag_key_value: The value of the tag. Pass None to exclude
"""
try:
#Train the model
status=""
logger.info("training model version %s for project %s",
version_name, project_arn)
output_config = json.loads(
'{"S3Bucket": "'
+ output_bucket
+ '", "S3KeyPrefix": "'
+ output_folder
+ '" } '
)
tags={}
if tag_key is not None and tag_key_value is not None:
tags = json.loads(
'{"' + tag_key + '":"' + tag_key_value + '"}'
)
response=rek_client.create_project_version(
ProjectArn=project_arn,
VersionName=version_name,
OutputConfig=output_config,
Tags=tags
)
logger.info("Started training: %s", response['ProjectVersionArn'])
# Wait for the project version training to complete.
project_version_training_completed_waiter = rek_client.get_waiter('project_version_training_completed')
project_version_training_completed_waiter.wait(ProjectArn=project_arn,
VersionNames=[version_name])
# Get the completion status.
describe_response=rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in describe_response['ProjectVersionDescriptions']:
logger.info("Status: %s", model['Status'])
logger.info("Message: %s", model['StatusMessage'])
status=model['Status']
logger.info("finished training")
return response['ProjectVersionArn'], status
except ClientError as err:
logger.exception("Couldn't create model: %s", err.response['Error']['Message'] )
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project in which you want to train a model"
)
parser.add_argument(
"version_name", help="A version name of your choosing."
)
parser.add_argument(
"output_bucket", help="The S3 bucket that receives the training results."
)
parser.add_argument(
"output_folder", help="The folder in the S3 bucket where training results are stored."
)
parser.add_argument(
"--tag_name", help="The name of a tag to attach to the model", required=False
)
parser.add_argument(
"--tag_value", help="The value for the tag.", required=False
)
def main():
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
try:
# Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(f"Training model version {args.version_name} for project {args.project_arn}")
# Train the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
model_arn, status=train_model(rekognition_client,
args.project_arn,
args.version_name,
args.output_bucket,
args.output_folder,
args.tag_name,
args.tag_value)
print(f"Finished training model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
except Exception as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
if __name__ == "__main__":
main()
- Java V2
-
En el siguiente ejemplo se ve cómo se entrena un modelo. Indique los siguientes argumentos de línea de comandos:
project_arn
: el nombre de recurso de Amazon (ARN) del proyecto.
version_name
: el nombre único de la versión del modelo que elija.
output_bucket
: el nombre del bucket de Amazon S3 en el que Etiquetas personalizadas de Amazon Rekognition guarda los resultados del entrenamiento.
output_folder
: el nombre de la carpeta donde se guardan los resultados del entrenamiento.
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TrainModel {
public static final Logger logger = Logger.getLogger(TrainModel.class.getName());
public static String trainMyModel(RekognitionClient rekClient, String projectArn, String versionName,
String outputBucket, String outputFolder) {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
logger.log(Level.INFO, "Training Model for project {0}", projectArn);
CreateProjectVersionRequest createProjectVersionRequest = CreateProjectVersionRequest.builder()
.projectArn(projectArn).versionName(versionName).outputConfig(outputConfig).build();
CreateProjectVersionResponse response = rekClient.createProjectVersion(createProjectVersionRequest);
logger.log(Level.INFO, "Model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Training model...");
// wait until training completes
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(projectArn)
.build();
RekognitionWaiter waiter = rekClient.waiter();
WaiterResponse<DescribeProjectVersionsResponse> waiterResponse = waiter
.waitUntilProjectVersionTrainingCompleted(describeProjectVersionsRequest);
Optional<DescribeProjectVersionsResponse> optionalResponse = waiterResponse.matched().response();
DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
System.out.println("Status: " + projectVersionDescription.statusAsString());
System.out.println("Message: " + projectVersionDescription.statusMessage());
}
return response.projectVersionArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String versionName = null;
String projectArn = null;
String projectVersionArn = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: " + "<project_name> <version_name> <output_bucket> <output_folder>\n\n" + "Where:\n"
+ " project_arn - The ARN of the project that you want to use. \n\n"
+ " version_name - A version name for the model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
versionName = args[1];
bucket = args[2];
location = args[3];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Train model
projectVersionArn = trainMyModel(rekClient, projectArn, versionName, bucket, location);
System.out.println(String.format("Created model: %s for Project ARN: %s", projectVersionArn, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
Si hay algún problema con el entrenamiento, consulte Depuración de un modelo de entrenamiento con errores.