Detención de un modelo (consola)Detención de un modelo (SDK)

Detención de un modelo de Etiquetas personalizadas de Amazon Rekognition

Puede dejar de ejecutar un modelo de etiquetas personalizadas de Amazon Rekognition mediante la consola o mediante la operación Version. StopProject

Temas

Detención de un modelo de Etiquetas personalizadas de Amazon Rekognition (consola)
Detención de un modelo de Etiquetas personalizadas de Amazon Rekognition (SDK)

Detención de un modelo de Etiquetas personalizadas de Amazon Rekognition (consola)

Utilice el siguiente procedimiento para dejar de ejecutar un modelo de Etiquetas personalizadas de Amazon Rekognition con la consola. Puede detener el modelo directamente desde la consola o utilizar el código del AWS SDK proporcionado por la consola.

Cómo detener un modelo (consola)

Abra la consola de Amazon Rekognition en https://console.aws.amazon.com/rekognition/.
Elija Usar etiquetas personalizadas.
Elija Comenzar.
En el panel de navegación izquierdo, elija Proyectos.
En la página Proyectos, elija el proyecto que contiene el modelo entrenado que quiera detener.
En la sección Modelos, elija el modelo que desee detener.
Seleccione la pestaña Usar modelo.
Stop model using the console
En la sección Iniciar o detener modelo, seleccione Detener.

En el cuadro de diálogo Detener modelo, escriba detener para confirmar que desea detener el modelo.

Seleccione Detener para detener el modelo.
Stop model using the AWS SDK
En la sección Usar su modelo, realice lo siguiente:
Elija Código de API.

Elija AWS CLI o Python.
En Detener modelo, copie el código de ejemplo.
Utilice el código de ejemplo para detener el modelo. Para obtener más información, consulte Detención de un modelo de Etiquetas personalizadas de Amazon Rekognition (SDK).
Elija el nombre del proyecto en la parte superior de la página para volver a la página de información general del proyecto.
En la sección Modelo, compruebe el estado del modelo. El modelo se habrá detenido cuando el estado del modelo esté en DETENIDO.

Detención de un modelo de Etiquetas personalizadas de Amazon Rekognition (SDK)

Para detener un modelo, llame a la API de StopProjectversión y pase el nombre de recurso de Amazon (ARN) del modelo en el parámetro de ProjectVersionArn entrada.

Es posible que el modelo tarde un tiempo en detenerse. Para comprobar el estado actual, use DescribeProjectVersions.

Cómo detener un modelo (SDK)

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

Utilice el código de ejemplo para iniciar un modelo.

CLI

Cambie el valor de project-version-arn por el ARN de la versión del modelo que desee detener.


aws rekognition stop-project-version --project-version-arn "model arn" \
  --profile custom-labels-access

Python

En el siguiente ejemplo se detiene un modelo que ya se está ejecutando.

Indique los siguientes parámetros de línea de comandos:

project_arn: el ARN del proyecto que incluye el modelo que desea detener.
model_arn: el ARN del modelo que desea detener.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
Shows how to stop a running Amazon Lookout for Vision model.
"""

import argparse
import logging
import time
import boto3

from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)


def get_model_status(rek_client, project_arn, model_arn):
    """
    Gets the current status of an Amazon Rekognition Custom Labels model
    :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
    :param project_name:  The name of the project that you want to use.
    :param model_arn:  The name of the model that you want the status for.
    """

    logger.info ("Getting status for %s.", model_arn)

    # Extract the model version from the model arn.
    version_name=(model_arn.split("version/",1)[1]).rpartition('/')[0]

    # Get the model status.
    models=rek_client.describe_project_versions(ProjectArn=project_arn,
    VersionNames=[version_name])

    for model in models['ProjectVersionDescriptions']: 
        logger.info("Status: %s",model['StatusMessage'])
        return model["Status"]

    # No model found.
    logger.exception("Model %s not found.", model_arn)
    raise Exception("Model %s not found.", model_arn)


def stop_model(rek_client, project_arn, model_arn):
    """
    Stops a running Amazon Rekognition Custom Labels Model.
    :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
    :param project_arn: The ARN of the project that you want to stop running.
    :param model_arn:  The ARN of the model (ProjectVersion) that you want to stop running.
    """

    logger.info("Stopping model: %s", model_arn)

    try:
        # Stop the model.
        response=rek_client.stop_project_version(ProjectVersionArn=model_arn)

        logger.info("Status: %s", response['Status'])

        # stops when hosting has stopped or failure.
        status = ""
        finished = False

        while finished is False:

            status=get_model_status(rek_client, project_arn, model_arn)

            if status == "STOPPING":
                logger.info("Model stopping in progress...")
                time.sleep(10)
                continue
            if status == "STOPPED":
                logger.info("Model is not running.")
                finished = True
                continue

            error_message = f"Error stopping model. Unexepected state: {status}"
            logger.exception(error_message)
            raise Exception(error_message)

        logger.info("finished. Status %s", status)
        return status

    except ClientError as err:
        logger.exception("Couldn't stop model - %s: %s",
           model_arn,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 that contains the model that you want to stop."
    )
    parser.add_argument(
        "model_arn", help="The ARN of the model that you want to stop."
    )

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()

        # Stop the model.
        session = boto3.Session(profile_name='custom-labels-access')
        rekognition_client = session.client("rekognition")

        status=stop_model(rekognition_client, args.project_arn, args.model_arn)

        print(f"Finished stopping model: {args.model_arn}")
        print(f"Status: {status}")

    except ClientError as err:
        logger.exception("Problem stopping model:%s",err)
        print(f"Failed to stop model: {err}")
    
    except Exception as err:
        logger.exception("Problem stopping model:%s", err)
        print(f"Failed to stop model: {err}")

if __name__ == "__main__":
    main()

Java V2

Indique los siguientes parámetros de línea de comandos:

project_arn: el ARN del proyecto que incluye el modelo que desea detener.
model_arn: el ARN del modelo que desea detener.


/*
   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.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionStatus;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.StopProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.StopProjectVersionResponse;


import java.util.logging.Level;
import java.util.logging.Logger;

public class StopModel {

    public static final Logger logger = Logger.getLogger(StopModel.class.getName());

    public static int findForwardSlash(String modelArn, int n) {

        int start = modelArn.indexOf('/');
        while (start >= 0 && n > 1) {
            start = modelArn.indexOf('/', start + 1);
            n -= 1;
        }
        return start;

    }

    public static void stopMyModel(RekognitionClient rekClient, String projectArn, String modelArn)
            throws Exception, RekognitionException {

        try {

            logger.log(Level.INFO, "Stopping {0}", modelArn);

            StopProjectVersionRequest stopProjectVersionRequest = StopProjectVersionRequest.builder()
                    .projectVersionArn(modelArn).build();

            StopProjectVersionResponse response = rekClient.stopProjectVersion(stopProjectVersionRequest);

            logger.log(Level.INFO, "Status: {0}", response.statusAsString());

            // Get the model version

            int start = findForwardSlash(modelArn, 3) + 1;
            int end = findForwardSlash(modelArn, 4);

            String versionName = modelArn.substring(start, end);

            // wait until model stops

            DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
                    .projectArn(projectArn).versionNames(versionName).build();

            boolean stopped = false;

            // Wait until create finishes

            do {

                DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
                        .describeProjectVersions(describeProjectVersionsRequest);

                for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
                        .projectVersionDescriptions()) {

                    ProjectVersionStatus status = projectVersionDescription.status();

                    logger.log(Level.INFO, "stopping model: {0} ", modelArn);

                    switch (status) {

                    case STOPPED:
                        logger.log(Level.INFO, "Model stopped");
                        stopped = true;
                        break;

                    case STOPPING:
                        Thread.sleep(5000);
                        break;

                    case FAILED:
                        String error = "Model stopping failed: " + projectVersionDescription.statusAsString() + " "
                                + projectVersionDescription.statusMessage() + " " + modelArn;
                        logger.log(Level.SEVERE, error);
                        throw new Exception(error);

                    default:
                        String unexpectedError = "Unexpected stopping state: "
                                + projectVersionDescription.statusAsString() + " "
                                + projectVersionDescription.statusMessage() + " " + modelArn;
                        logger.log(Level.SEVERE, unexpectedError);
                        throw new Exception(unexpectedError);
                    }
                }

            } while (stopped == false);

        } catch (RekognitionException e) {
            logger.log(Level.SEVERE, "Could not stop model: {0}", e.getMessage());
            throw e;
        }

    }

    public static void main(String[] args) {

        String modelArn = null;
        String projectArn = null;


        final String USAGE = "\n" + "Usage: " + "<project_name> <version_name>\n\n" + "Where:\n"
                + "   project_arn - The ARN of the project that contains the model that you want to stop. \n\n"
                + "   model_arn - The ARN of the model version that you want to stop.\n\n";

        if (args.length != 2) {
            System.out.println(USAGE);
            System.exit(1);
        }

        projectArn = args[0];
        modelArn = args[1];


        try {

            // Get the Rekognition client.
            RekognitionClient rekClient = RekognitionClient.builder()
            .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
            .region(Region.US_WEST_2)
            .build();

            // Stop model
            stopMyModel(rekClient, projectArn, modelArn);

            System.out.println(String.format("Model stopped: %s", modelArn));

            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);
        }

    }

}

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Inicio de un modelo

Informes sobre la duración y las unidades de inferencia