Entrenamiento del modelo

Después de crear los conjuntos de datos y etiquetar las imágenes, puede entrenar el modelo. Como parte del proceso de entrenamiento, se utiliza un conjunto de datos de prueba. Si tiene un proyecto de conjunto de datos único, las imágenes del conjunto de datos se dividen automáticamente en un conjunto de datos de prueba y un conjunto de datos de entrenamiento como parte del proceso de entrenamiento. Si su proyecto tiene un conjunto de datos de entrenamiento y uno de prueba, se utilizan para entrenar y probar el conjunto de datos por separado.

Una vez finalizado el entrenamiento, puede evaluar el rendimiento del modelo y realizar las mejoras necesarias. Para obtener más información, consulte Mejorar su modelo Amazon Lookout for Vision.

Para entrenar el modelo, Amazon Lookout for Vision hace una copia de las imágenes de origen de entrenamiento y prueba. De forma predeterminada, las imágenes copiadas se cifran con una clave que AWS posee y administra. También puede optar por utilizar su propia AWS clave del Servicio de administración de claves (KMS). Para obtener más información, consulte Conceptos del servicio de administración de AWS claves. Las imágenes de origen no se ven afectadas.

Puede asignar metadatos a su modelo en forma de etiquetas. Para obtener más información, consulte Etiquetado de modelos.

Cada vez que entrena un modelo, se crea una nueva versión del modelo. Si ya no necesita una versión de un modelo, puede eliminarla. Para obtener más información, consulte Eliminación de un modelo.

Se le cobrará por el tiempo que tarda en entrenarse correctamente el modelo. Para obtener más información, consulte Horas de entrenamiento.

Para ver los modelos existentes en un proyecto, Visualización de los modelos.

nota

Si acaba de completar Creación de un conjunto de datos oAñadir imágenes a su conjunto de datos.. En este momento, la consola debería mostrar el panel de control del modelo y no es necesario que realices los pasos del 1 al 4.

Entrenamiento de un modelo (consola)

En el siguiente procedimiento se muestra cómo verificar un dominio utilizando la consola.

Para entrenar su modelo (consola)

1. Abre la consola https://console.aws.amazon.com/lookoutvision/Amazon Lookout for Vision en.

2. En el panel de navegación izquierdo, elija Proyectos.

3. En la página Proyectos, elija el proyecto que contiene el modelo entrenado que desee entrenar.

4. En la página de detalles del proyecto, elija Entrenar modelo. El botón Entrenar modelo está disponible si tiene suficientes imágenes etiquetadas para entrenar el modelo. Si el botón no está disponible, añada más imágenes hasta que tenga suficientes imágenes etiquetadas.

5. (Opcional) Si desea utilizar su propia clave de AWS KMS cifrado, haga lo siguiente:

   1. En Cifrado de datos de imagen, elija Personalizar la configuración de cifrado (avanzado).

   2. En encryption.aws_kms_key, introduce el nombre del recurso de Amazon ARN () de tu clave o elige una clave existente. AWS KMS Para crear una clave nueva, elija Crear una clave. AWS IMS

6. (Opcional) Si desea agregar etiquetas al modelo, haga lo siguiente:

   1. En la sección Etiquetas, elija Agregar nueva etiqueta.

   2. Introduzca lo siguiente:

      1. El nombre de la clave en Key.

      2. El valor de la clave en Valor.

   3. Para añadir más etiquetas, repita los pasos 6a y 6b.

   4. (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.

7. Elija Entrenar modelo.

8. En el cuadro de diálogo ¿Quiere entrenar su modelo?, escoja Entrenar modelo.

9. En la vista de modelos, puede ver que el entrenamiento ha comenzado y comprobar el estado actual consultando la columna Status correspondiente a la versión del modelo. El entrenamiento de un modelo tarda un tiempo en completarse.

10. Cuando finalice el entrenamiento, podrá evaluar su rendimiento. Para obtener más información, consulte Mejorar su modelo Amazon Lookout for Vision.

Entrenando a un modelo (SDK)

La CreateModeloperación se utiliza para iniciar el entrenamiento, las pruebas y la evaluación de un modelo. Amazon Lookout for Vision entrena el modelo mediante el conjunto de datos de entrenamiento y pruebas asociado al proyecto. Para obtener más información, consulte Crear un proyecto () SDK.

Cada vez que llame a CreateModel, crea una nueva versión del modelo. La respuesta de CreateModel incluye la versión del modelo.

Se le cobrará por cada entrenamiento de modelo exitoso. Utilice el parámetro ClientToken de entrada para evitar que sus usuarios repitan innecesariamente o accidentalmente el entrenamiento con el modelo. ClientTokenes un parámetro de entrada idempotente que garantiza que CreateModel solo se complete una vez para un conjunto específico de parámetros. Si se repite una llamada a CreateModel con el mismo ClientToken valor, se garantiza que el entrenamiento no se repita. Si no proporciona un valor paraClientToken, el elemento AWS SDK que está utilizando inserta un valor para usted. Esto evita que los reintentos tras un error de red inicien varios trabajos de entrenamiento, pero tendrá que proporcionar su propio valor para sus propios casos de uso. Para obtener más información, consulte CreateModel.

El entrenamiento tarda un tiempo en completarse. Para comprobar el estado actual, llame DescribeModel y pase el nombre del proyecto (especificado en la llamada aCreateProject) y la versión del modelo. El status campo indica el estado actual del entrenamiento del modelo. Para ver el código de ejemplo, consulte Visualización de sus modelos (SDK).

Si el entrenamiento es exitoso, puede evaluar el modelo. Para obtener más información, consulte Mejorar su modelo Amazon Lookout for Vision.

Para ver los modelos que ha creado en un proyecto, llameListModels. Para ver el código de ejemplo, consulte Visualización de los modelos.

Para entrenar a un modelo (SDK)

1. Si aún no lo ha hecho, instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte Paso 4: Configura los AWS SDK AWS CLI y.

2. Utilice el siguiente código de ejemplo para entrenar un modelo.

   CLI

   Cambie los siguientes valores:

   • project-nameal nombre del proyecto que contiene el modelo que desea crear.

   • output-configa la ubicación en la que desee guardar los resultados del entrenamiento. Reemplace los siguientes valores:

     • output bucketcon el nombre del bucket de Amazon S3 en el que Amazon Lookout for Vision guarda los resultados del entrenamiento.

     • output foldercon el nombre de la carpeta en la que desea guardar los resultados del entrenamiento.

     • Key con el nombre de clave de una etiqueta.

     • Valuecon un valor al que asociarsetag_key.

   aws lookoutvision create-model --project-name "project name"\
     --output-config '{ "S3Location": { "Bucket": "output bucket", "Prefix":  "output folder" } }'\
     --tags '[{"Key":"Key","Value":"Value"}]' \
     --profile lookoutvision-access

   Python

   Este código se ha tomado del GitHub repositorio de SDK ejemplos de AWS documentación. Consulte el ejemplo completo aquí.

       @staticmethod
       def create_model(
           lookoutvision_client,
           project_name,
           training_results,
           tag_key=None,
           tag_key_value=None,
       ):
           """
           Creates a version of a Lookout for Vision model.
   
           :param lookoutvision_client: A Boto3 Lookout for Vision client.
           :param project_name: The name of the project in which you want to create a
                                model.
           :param training_results: The Amazon S3 location where training results are stored.
           :param tag_key: The key for a tag to add to the model.
           :param tag_key_value - A value associated with the tag_key.
           return: The model status and version.
           """
           try:
               logger.info("Training model...")
               output_bucket, output_folder = training_results.replace("s3://", "").split(
                   "/", 1
               )
               output_config = {
                   "S3Location": {"Bucket": output_bucket, "Prefix": output_folder}
               }
               tags = []
               if tag_key is not None:
                   tags = [{"Key": tag_key, "Value": tag_key_value}]
   
               response = lookoutvision_client.create_model(
                   ProjectName=project_name, OutputConfig=output_config, Tags=tags
               )
   
               logger.info("ARN: %s", response["ModelMetadata"]["ModelArn"])
               logger.info("Version: %s", response["ModelMetadata"]["ModelVersion"])
               logger.info("Started training...")
   
               print("Training started. Training might take several hours to complete.")
   
               # Wait until training completes.
               finished = False
               status = "UNKNOWN"
               while finished is False:
                   model_description = lookoutvision_client.describe_model(
                       ProjectName=project_name,
                       ModelVersion=response["ModelMetadata"]["ModelVersion"],
                   )
                   status = model_description["ModelDescription"]["Status"]
   
                   if status == "TRAINING":
                       logger.info("Model training in progress...")
                       time.sleep(600)
                       continue
   
                   if status == "TRAINED":
                       logger.info("Model was successfully trained.")
                   else:
                       logger.info(
                           "Model training failed: %s ",
                           model_description["ModelDescription"]["StatusMessage"],
                       )
                   finished = True
           except ClientError:
               logger.exception("Couldn't train model.")
               raise
           else:
               return status, response["ModelMetadata"]["ModelVersion"]
   
   

   Java V2

   Este código se ha tomado del GitHub repositorio de SDK ejemplos de AWS documentación. Consulte el ejemplo completo aquí.

   /**
    * Creates an Amazon Lookout for Vision model. The function returns after model
    * training completes. Model training can take multiple hours to complete.
    * You are charged for the amount of time it takes to successfully train a model.
    * Returns after Lookout for Vision creates the dataset.
    * 
    * @param lfvClient   An Amazon Lookout for Vision client.
    * @param projectName The name of the project in which you want to create a
    *                    model.
    * @param description A description for the model.
    * @param bucket      The S3 bucket in which Lookout for Vision stores the
    *                    training results.
    * @param folder      The location of the training results within the S3
    *                    bucket.
    * @return ModelDescription The description of the created model.
    */
   public static ModelDescription createModel(LookoutVisionClient lfvClient, String projectName,
                   String description, String bucket, String folder)
                   throws LookoutVisionException, InterruptedException {
   
           logger.log(Level.INFO, "Creating model for project: {0}.", new Object[] { projectName });
   
           // Setup input parameters.
           S3Location s3Location = S3Location.builder()
                           .bucket(bucket)
                           .prefix(folder)
                           .build();
   
           OutputConfig config = OutputConfig.builder()
                           .s3Location(s3Location)
                           .build();
   
           CreateModelRequest createModelRequest = CreateModelRequest.builder()
                           .projectName(projectName)
                           .description(description)
                           .outputConfig(config)
                           .build();
   
           // Create and train the model.
           CreateModelResponse response = lfvClient.createModel(createModelRequest);
   
           String modelVersion = response.modelMetadata().modelVersion();
           boolean finished = false;
           DescribeModelResponse descriptionResponse = null;
   
           // Wait until training finishes or fails.
   
           do {
                   DescribeModelRequest describeModelRequest = DescribeModelRequest.builder()
                                   .projectName(projectName)
                                   .modelVersion(modelVersion)
                                   .build();
   
                   descriptionResponse = lfvClient.describeModel(describeModelRequest);
   
                   switch (descriptionResponse.modelDescription().status()) {
                           case TRAINED:
                                   logger.log(Level.INFO, "Model training completed for project {0} version {1}.",
                                                   new Object[] { projectName, modelVersion });
                                   finished = true;
                                   break;
   
                           case TRAINING:
                                   logger.log(Level.INFO,
                                                   "Model training in progress for project {0} version {1}.",
                                                   new Object[] { projectName, modelVersion });
                                   TimeUnit.SECONDS.sleep(60);
   
                                   break;
   
                           case TRAINING_FAILED:
                                   logger.log(Level.SEVERE,
                                                   "Model training failed for for project {0} version {1}.",
                                                   new Object[] { projectName, modelVersion });
                                   finished = true;
                                   break;
   
                           default:
                                   logger.log(Level.SEVERE,
                                                   "Unexpected error when training model project {0} version {1}: {2}.",
                                                   new Object[] { projectName, modelVersion,
                                                                   descriptionResponse.modelDescription()
                                                                                   .status() });
                                   finished = true;
                                   break;
   
                   }
           } while (!finished);
   
           return descriptionResponse.modelDescription();
   
   }

3. Cuando finalice el entrenamiento, podrá evaluar su rendimiento. Para obtener más información, consulte Mejorar su modelo Amazon Lookout for Vision.