Como iniciar ou interromper um modelo (console)Como iniciar um modelo (SDK)

Como iniciar um modelo do Amazon Rekognition Custom Labels

Você pode começar a executar um modelo de etiquetas personalizadas do Amazon Rekognition usando o console ou usando a operação Version. StartProject

Importante

Há uma cobrança pelo número de horas em que seu modelo está em execução e pelo número de unidades de inferência que seu modelo usa enquanto está em execução. Para ter mais informações, consulte Como executar um modelo do Amazon Rekognition Custom Labels.

A inicialização de um modelo pode levar alguns minutos para ser concluída. Para verificar o status atual da prontidão do modelo, verifique a página de detalhes do projeto ou use DescribeProjectVersões.

Depois que o modelo é iniciado, você usa DetectCustomrótulos para analisar imagens usando o modelo. Para ter mais informações, consulte Como analisar uma imagem com um modelo treinado. O console também fornece um código de exemplo para chamar DetectCustomLabels.

Tópicos

Como iniciar um modelo do Amazon Rekognition Custom Labels (console)
Como iniciar um modelo do Amazon Rekognition Custom Labels (SDK)

Como iniciar um modelo do Amazon Rekognition Custom Labels (console)

Use o procedimento a seguir para começar a executar um modelo do Amazon Rekognition Custom Labels com o console. Você pode iniciar o modelo diretamente do console ou usar o código AWS SDK fornecido pelo console.

Para iniciar um modelo (console)

Abra o console do Amazon Rekognition em https://console.aws.amazon.com/rekognition/.
Escolha Usar rótulos personalizados.
Escolha Comece a usar.
No painel de navegação esquerdo, selecione Projetos.
Na página de recursos Projetos, selecione o projeto que contém o modelo treinado que você deseja iniciar.
Na seção Modelos, escolha o modelo que deseja iniciar.
Escolha a guia Usar modelo.
Execute um destes procedimentos:
Start model using the console
Na seção Iniciar ou interromper o modelo, faça o seguinte:
Selecione o número de unidades de inferência que deseja usar. Para ter mais informações, consulte Como executar um modelo do Amazon Rekognition Custom Labels.
Escolha Iniciar.
Na caixa de diálogo Iniciar modelo, escolha Iniciar.
Start model using the AWS SDK
Na seção Use seu modelo, faça o seguinte:
Escolha Código da API.

Escolha AWS CLI ou Python.
Em Iniciar modelo, copie o código de exemplo.
Use o código de exemplo para iniciar seu modelo. Para ter mais informações, consulte Como iniciar um modelo do Amazon Rekognition Custom Labels (SDK).
Para voltar à página de visão geral do projeto, escolha o nome do seu projeto na parte superior da página.
Na seção Modelo, verifique o status do modelo. Quando o status do modelo é EXECUTANDO, é possível usar o modelo para analisar imagens. Para ter mais informações, consulte Como analisar uma imagem com um modelo treinado.

Como iniciar um modelo do Amazon Rekognition Custom Labels (SDK)

Você inicia um modelo chamando a API de StartProjectversão e passando o Amazon Resource Name (ARN) do modelo no parâmetro de ProjectVersionArn entrada. Também é possível especificar o número de unidades de inferência que deseja usar. Para ter mais informações, consulte Como executar um modelo do Amazon Rekognition Custom Labels.

Um modelo pode demorar um pouco para ser iniciado. Os exemplos em Python e Java neste tópico usam esperadores para aguardar o início do modelo. Um agentes de espera é um métodos utilitário que sonda um determinado estado para verificar se ele ocorreu em um cliente. Como alternativa, você pode verificar o status atual chamando DescribeProjectVersões.

Para iniciar um modelo (SDK)

Se você ainda não tiver feito isso, instale e configure o AWS CLI e os AWS SDKs. Para ter mais informações, consulte Etapa 4: configurar o AWS CLI e AWS SDKs.

Use o código de exemplo a seguir para iniciar um modelo.

CLI

Altere o valor de project-version-arn para o ARN do modelo que você deseja iniciar. Altere o valor de --min-inference-units para o número de unidades de inferência que você deseja usar. Você tem a opção de alterar --max-inference-units para o número máximo de unidades de inferência que o Amazon Rekognition Custom Labels pode usar para escalar automaticamente o modelo.


aws rekognition start-project-version  --project-version-arn model_arn \
   --min-inference-units minimum number of units \
   --max-inference-units maximum number of units \
   --profile custom-labels-access

Python

Forneça os seguintes parâmetros de linha de comando:

project_arn: o ARN do projeto que contém o modelo que você deseja iniciar.
model_arn: o ARN do modelo que você deseja iniciar.
min_inference_units: o número de unidades de inferência que você deseja usar.
(Opcional) --max_inference_units O número máximo de unidades de inferência que o Amazon Rekognition Custom Labels pode usar para escalar automaticamente o modelo.


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

"""
Purpose
Shows how to start running an Amazon Lookout for Vision model.
"""

import argparse
import logging
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.
    :return: The model status
    """

    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]

    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"]

    error_message = f"Model {model_arn} not found."
    logger.exception(error_message)
    raise Exception(error_message)


def start_model(rek_client, project_arn, model_arn, min_inference_units, max_inference_units=None):
    """
    Starts the hosting 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 contains the
    model that you want to start hosting.
    :param min_inference_units: The number of inference units to use for hosting.
    :param max_inference_units: The number of inference units to use for auto-scaling
    the model. If not supplied, auto-scaling does not happen.
    """

    try:
        # Start the model
        logger.info(f"Starting model: {model_arn}. Please wait....")

        if max_inference_units is None:
            rek_client.start_project_version(ProjectVersionArn=model_arn,
                                             MinInferenceUnits=int(min_inference_units))
        else:
            rek_client.start_project_version(ProjectVersionArn=model_arn,
                                             MinInferenceUnits=int(
                                                 min_inference_units),
                                             MaxInferenceUnits=int(max_inference_units))

        # Wait for the model to be in the running state
        version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0]
        project_version_running_waiter = rek_client.get_waiter(
            'project_version_running')
        project_version_running_waiter.wait(
            ProjectArn=project_arn, VersionNames=[version_name])

        # Get the running status
        return get_model_status(rek_client, project_arn, model_arn)

    except ClientError as err:
        logger.exception("Client error: Problem starting model: %s", err)
        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 that the model you want to start."
    )
    parser.add_argument(
        "model_arn", help="The ARN of the model that you want to start."
    )
    parser.add_argument(
        "min_inference_units", help="The minimum number of inference units to use."
    )
    parser.add_argument(
        "--max_inference_units",  help="The maximum number of inference units to use for auto-scaling the model.", 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()

        # Start the model.
        session = boto3.Session(profile_name='custom-labels-access')
        rekognition_client = session.client("rekognition")
        
        status = start_model(rekognition_client,
                             args.project_arn, args.model_arn,
                             args.min_inference_units,
                             args.max_inference_units)

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

    except ClientError as err:
        error_message = f"Client error: Problem starting model: {err}"
        logger.exception(error_message)
        print(error_message)

    except Exception as err:
        error_message = f"Problem starting model:{err}"
        logger.exception(error_message)
        print(error_message)


if __name__ == "__main__":
    main()

Java V2

Forneça os seguintes parâmetros de linha de comando:

project_arn: o ARN do projeto que contém o modelo que você deseja iniciar.
model_arn: o ARN do modelo que você deseja iniciar.
min_inference_units: o número de unidades de inferência que você deseja usar.
(Opcional) max_inference_units: o número máximo de unidades de inferência que o Amazon Rekognition Custom Labels pode usar para escalar automaticamente o modelo. Se não especificar um valor, o escalonamento automático não acontecerá.


/*
   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.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.StartProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.StartProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;

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

public class StartModel {

    public static final Logger logger = Logger.getLogger(StartModel.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 startMyModel(RekognitionClient rekClient, String projectArn, String modelArn,
            Integer minInferenceUnits, Integer maxInferenceUnits
            ) throws Exception, RekognitionException {

        try {
            
            logger.log(Level.INFO, "Starting model: {0}", modelArn);
            
            StartProjectVersionRequest startProjectVersionRequest = null;
            
            if (maxInferenceUnits == null) {
                startProjectVersionRequest = StartProjectVersionRequest.builder()
                    .projectVersionArn(modelArn)
                    .minInferenceUnits(minInferenceUnits)
                    .build();
            }
            else {
                startProjectVersionRequest = StartProjectVersionRequest.builder()
                        .projectVersionArn(modelArn)
                        .minInferenceUnits(minInferenceUnits)
                        .maxInferenceUnits(maxInferenceUnits)
                        .build();
                
            }

            StartProjectVersionResponse response = rekClient.startProjectVersion(startProjectVersionRequest);

            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 starts

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

            RekognitionWaiter waiter = rekClient.waiter();

            WaiterResponse<DescribeProjectVersionsResponse> waiterResponse = waiter
                    .waitUntilProjectVersionRunning(describeProjectVersionsRequest);

            Optional<DescribeProjectVersionsResponse> optionalResponse = waiterResponse.matched().response();

            DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();

            for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
                    .projectVersionDescriptions()) {
                if(projectVersionDescription.status() == ProjectVersionStatus.RUNNING) {
                    logger.log(Level.INFO, "Model is running" );
                 
                }
                else {
                    String error = "Model training failed: " + projectVersionDescription.statusAsString() + " "
                            + projectVersionDescription.statusMessage() + " " + modelArn;
                    logger.log(Level.SEVERE, error);
                    throw new Exception(error);
                }
                
            }


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

    }

    public static void main(String[] args) {

        String modelArn = null;
        String projectArn = null;
        Integer minInferenceUnits = null;
        Integer maxInferenceUnits = null;
        



        final String USAGE = "\n" + "Usage: " + "<project_name> <version_name> <min_inference_units> <max_inference_units>\n\n" + "Where:\n"
                + "   project_arn - The ARN of the project that contains the model that you want to start. \n\n"
                + "   model_arn - The ARN of the model version that you want to start.\n\n"
                + "   min_inference_units - The number of inference units to start the model with.\n\n"
                + "   max_inference_units - The maximum number of inference units that Custom Labels can use to "
                + "   automatically scale the model. If the value is null, automatic scaling doesn't happen.\n\n";

        if (args.length < 3  || args.length >4) {
            System.out.println(USAGE);
            System.exit(1);
        }

        projectArn = args[0];
        modelArn = args[1];
        minInferenceUnits=Integer.parseInt(args[2]);
        
        if (args.length == 4) {
            maxInferenceUnits = Integer.parseInt(args[3]);
        }
  
        try {


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

            // Start the model.
            startMyModel(rekClient, projectArn, modelArn, minInferenceUnits, maxInferenceUnits);
            

            System.out.println(String.format("Model started: %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);
        }

        

    }

}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Como executar um modelo treinado

Como interromper um modelo