As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Como executar um modelo do Amazon Rekognition Custom Labels Se estiver satisfeito com o desempenho do modelo, poderá começar a usá-lo. Você pode iniciar e interromper um modelo usando o console ou o AWS SDK. O console também inclui exemplos de operações do SDK que podem ser usados. **Topics** + [Unidades de inferência](#running-model-inference-units) + [Zonas de disponibilidade](#running-model-availability-zones) + [Como iniciar um modelo do Amazon Rekognition Custom Labels](rm-start.md) + [Como interromper um modelo do Amazon Rekognition Custom Labels](rm-stop.md) + [Duração do relatório de execução e unidades de inferência usadas](rm-model-usage.md) ## Unidades de inferência Ao iniciar seu modelo, especifique o número de recursos computacionais, conhecidos como unidade de inferência, que o modelo usa. **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 com base em como a execução do seu modelo é configurada. Por exemplo, se você iniciar o modelo com duas unidades de inferência e usar o modelo por oito horas, haverá uma cobrança por 16 horas de inferência (oito horas de tempo de execução \$1 duas unidades de inferência). Para obter mais informações, consulte [Horas de inferência](https://aws.amazon.com/rekognition/pricing/#Amazon_Rekognition_Custom_Labels_pricing). Se não [interromper seu modelo](rm-stop.md) explicitamente, haverá uma cobrança mesmo que não esteja analisando ativamente as imagens com seu modelo. As transações por segundo (TPS) compatíveis com uma única unidade de inferência são afetadas por: + Um modelo que detecta rótulos em nível de imagem (classificação) geralmente tem um TPS maior do que um modelo que detecta e localiza objetos com caixas delimitadoras (detecção de objetos). + A complexidade do modelo. + Uma imagem de alta resolução requer mais tempo para análise. + Mais objetos em uma imagem exigem mais tempo para análise. + Imagens menores são analisadas mais rapidamente do que imagens maiores. + Uma imagem passada como bytes de imagem é analisada mais rapidamente do que primeiro fazer upload da imagem em um bucket do Amazon S3 e referenciar a imagem carregada. As imagens passadas como bytes de imagem devem ter menos de 4,0 MB. É recomendável usar bytes de imagem para processamento de imagens quase em tempo real e quando o tamanho da imagem for menor que 4,0 MB. Por exemplo, imagens capturadas de uma câmera IP. + O processamento de imagens armazenadas em um bucket do Amazon S3 é mais rápido do que baixar as imagens, convertê-las em bytes de imagem e passar os bytes da imagem para análise. + Analisar uma imagem já armazenada em um bucket do Amazon S3 é provavelmente mais rápido do que analisar a mesma imagem passada como bytes de imagem. Isso é bem válido se o tamanho da imagem for maior. Se o número de chamadas para `DetectCustomLabels` exceder o máximo de TPS compatíveis com a soma das unidades de inferência que um modelo usa, o Amazon Rekognition Custom Labels retornará uma exceção `ProvisionedThroughputExceededException`. ### Como gerenciar o throughput com unidades de inferência É possível aumentar ou diminuir o throughput do seu modelo, dependendo das demandas da sua aplicação. Para aumentar o throughput, use unidades de inferência adicionais. Cada unidade de inferência adicional aumenta sua velocidade de processamento em uma unidade de inferência. Para obter informações sobre como calcular o número de unidades de inferência necessárias, consulte [Calcular unidades de inferência para os modelos Amazon Rekognition Custom Labels e Amazon Lookout for Vision](https://aws.amazon.com/blogs/machine-learning/calculate-inference-units-for-an-amazon-rekognition-custom-labels-model/). Se quiser alterar o throughput compatível do modelo, você tem duas opções: #### Adicionar ou remover unidades de inferência manualmente [Pare](rm-stop.md) o modelo e [reinicie](rm-start.md) com o número necessário de unidades de inferência. A desvantagem dessa abordagem é que o modelo não pode receber solicitações durante a reinicialização e não pode ser usado para lidar com picos de demanda. Use esta abordagem se seu modelo tiver um throughput estável e seu caso de uso puder tolerar de 10 a 20 minutos de tempo de inatividade. Um exemplo seria se você quiser fazer chamadas em lote para seu modelo usando uma programação semanal. #### Unidades de inferência de ajuste de escala automático Se seu modelo precisar acomodar picos de demanda, o Amazon Rekognition Custom Labels pode escalar automaticamente o número de unidades de inferência que seu modelo usa. À medida que a demanda aumenta, o Amazon Rekognition Custom Labels adiciona unidades de inferência adicionais ao modelo e as remove quando a demanda diminui. Para permitir que o Amazon Rekognition Custom Labels escalem automaticamente as unidades de inferência de um modelo, [inicie](rm-start.md) o modelo e defina o número máximo de unidades de inferência que ele pode usar usando o parâmetro `MaxInferenceUnits`. Definir um número máximo de unidades de inferência permite gerenciar o custo de execução do modelo limitando o número de unidades de inferência disponíveis para ele. Se não especificar um número máximo de unidades, o Amazon Rekognition Custom Labels não escalará automaticamente seu modelo, usando apenas o número de unidades de inferência com as quais você começou. Para obter informações sobre o número máximo de unidades de inferência, consulte [Service Quotas](https://docs.aws.amazon.com/general/latest/gr/rekognition.html#limits_rekognition). Também é possível especificar um número mínimo de unidades de inferência usando o parâmetro `MinInferenceUnits`. Isto permite que você especifique o throughput mínimo para seu modelo, em que uma única unidade de inferência representa uma hora de tempo de processamento. **nota** É possível pode definir o número máximo de unidades de inferência com o console do Amazon Rekognition Custom Labels. Em vez disso, especifique o parâmetro de entrada `MaxInferenceUnits` para a operação `StartProjectVersion`. O Amazon Rekognition Custom Labels fornece CloudWatch as seguintes métricas do Amazon Logs que você pode usar para determinar o status atual de escalabilidade automática de um modelo. | Métrica | Description | | --- | --- | | `DesiredInferenceUnits` | O número de unidades de inferência que o Amazon Rekognition Custom Labels está aumentando ou diminuindo. | | `InServiceInferenceUnits` | O número de unidades de inferência que o modelo está usando. | Se `DesiredInferenceUnits` =`InServiceInferenceUnits`, o Amazon Rekognition Custom Labels não está escalando o número de unidades de inferência neste momento. Se `DesiredInferenceUnits` < `InServiceInferenceUnits`, o Amazon Rekognition Custom Labels está aumentando a escala verticalmente para o valor de `DesiredInferenceUnits`. Se `DesiredInferenceUnits` < `InServiceInferenceUnits`, o Amazon Rekognition Custom Labels está reduzindo a escala verticalmente para o valor de `DesiredInferenceUnits`. [Para obter mais informações sobre as métricas retornadas pelos rótulos personalizados do Amazon Rekognition e pelas dimensões de filtragem, consulte métricas do Rekognition. CloudWatch ](https://docs.aws.amazon.com/rekognition/latest/dg/cloudwatch-metricsdim.html) Para descobrir o número máximo de unidades de inferência que você solicitou para um modelo, chame `DescribeProjectsVersion` e verifique o campo `MaxInferenceUnits` na resposta. Para obter um código de exemplo, consulte [Como descrever um modelo (SDK)](md-describing-model-sdk.md). ## Zonas de disponibilidade O Amazon Rekognition Custom Labels distribui unidades de inferência em várias zonas de disponibilidade em uma região da AWS para oferecer maior disponibilidade. Para ter mais informações, consulte [zonas de disponibilidade](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/#Availability_Zones). Para ajudar a proteger seus modelos de produção contra interrupções na zona de disponibilidade e falhas na unidade de inferência, inicie seus modelos de produção com pelo menos duas unidades de inferência. Se ocorrer uma interrupção na zona de disponibilidade, todas as unidades de inferência na zona de disponibilidade ficarão indisponíveis e a capacidade do modelo será reduzida. As chamadas para [DetectCustomLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectCustomLabels)são redistribuídas nas unidades de inferência restantes. Estas chamadas têm sucesso se não excederem as transações por segundo (TPS) compatíveis com as unidades de inferência restantes. Depois que a AWS reparar a zona de disponibilidade, as unidades de inferência são reiniciadas e a capacidade total é restaurada. Se uma única unidade de inferência falhar, o Amazon Rekognition Custom Labels iniciará automaticamente uma nova unidade de inferência na mesma zona de disponibilidade. A capacidade do modelo é reduzida até que a nova unidade de inferência seja iniciada. # 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. [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion) **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 obter mais informações, consulte [Como executar um modelo do Amazon Rekognition Custom Labels](running-model.md). 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 uso [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions). Depois que o modelo é iniciado, você usa [DetectCustomLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectCustomLabels), para analisar imagens usando o modelo. Para obter mais informações, consulte [Como analisar uma imagem com um modelo treinado](detecting-custom-labels.md). O console também fornece um código de exemplo para chamar `DetectCustomLabels`. **Topics** + [Como iniciar um modelo do Amazon Rekognition Custom Labels (console)](#rm-start-console) + [Como iniciar um modelo do Amazon Rekognition Custom Labels (SDK)](#rm-start-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)** 1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) 1. Escolha **Usar rótulos personalizados**. 1. Escolha **Comece a usar**. 1. No painel de navegação esquerdo, selecione **Projetos**. 1. Na página de recursos **Projetos**, selecione o projeto que contém o modelo treinado que você deseja iniciar. 1. Na seção **Modelos**, escolha o modelo que deseja iniciar. 1. Escolha a guia **Usar modelo**. 1. Execute um destes procedimentos: ------ #### [ Start model using the console ] Na seção **Iniciar ou interromper o modelo**, faça o seguinte: 1. Selecione o número de unidades de inferência que deseja usar. Para obter mais informações, consulte [Como executar um modelo do Amazon Rekognition Custom Labels](running-model.md). 1. Escolha **Iniciar**. 1. 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: 1. Escolha **Código da API**. 1. Escolha **AWS CLI** ou **Python.** 1. Em **Iniciar modelo**, copie o código de exemplo. 1. Use o código de exemplo para iniciar seu modelo. Para obter mais informações, consulte [Como iniciar um modelo do Amazon Rekognition Custom Labels (SDK)](#rm-start-sdk). ------ 1. Para voltar à página de visão geral do projeto, escolha o nome do seu projeto na parte superior da página. 1. Na seção **Modelo**, verifique o status do modelo. Quando o status do modelo é **EXECUTANDO**, é possível usar o modelo para analisar imagens. Para obter mais informações, consulte [Como analisar uma imagem com um modelo treinado](detecting-custom-labels.md). ## Como iniciar um modelo do Amazon Rekognition Custom Labels (SDK) Você inicia um modelo chamando a [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion)API 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 obter mais informações, consulte [Como executar um modelo do Amazon Rekognition Custom Labels](running-model.md). 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 ligando [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions). **Para iniciar um modelo (SDK)** 1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md). 1. 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 waiterResponse = waiter .waitUntilProjectVersionRunning(describeProjectVersionsRequest); Optional 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: " + " \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); } } } ``` ------ # Como interromper um modelo do Amazon Rekognition Custom Labels Você pode parar de executar um modelo de etiquetas personalizadas do Amazon Rekognition usando o console ou usando a operação. [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion) **Topics** + [Como interromper um modelo do Amazon Rekognition Custom Labels (console)](#rm-stop-console) + [Como interromper um modelo do Amazon Rekognition Custom Labels (SDK)](#rm-stop-sdk) ## Como interromper um modelo do Amazon Rekognition Custom Labels (console) Use o procedimento a seguir para interromper um modelo em execução do Amazon Rekognition Custom Labels com o console. Você pode parar o modelo diretamente do console ou usar o código AWS SDK fornecido pelo console. **Para interromper um modelo (console)** 1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) 1. Escolha **Usar rótulos personalizados**. 1. Escolha **Comece a usar**. 1. No painel de navegação esquerdo, selecione **Projetos**. 1. Na página de recursos **Projetos**, selecione o projeto que contém o modelo treinado que você deseja interromper. 1. Na seção **Modelos**, escolha o modelo que deseja interromper. 1. Escolha a guia **Usar modelo**. 1. ------ #### [ Stop model using the console ] 1. Na seção **Iniciar ou interromper modelo**, escolha **Interromper**. 1. Na caixa de diálogo **Interromper modelo**, insira **interromper** para confirmar que deseja interromper o modelo. 1. Escolha **Parar** para interromper seu modelo. ------ #### [ Stop model using the AWS SDK ] Na seção **Use seu modelo**, faça o seguinte: 1. Escolha **Código da API**. 1. Escolha **AWS CLI** ou **Python.** 1. Em **Interromper modelo**, copie o código de exemplo. 1. Use o código de exemplo para interromper seu modelo. Para obter mais informações, consulte [Como interromper um modelo do Amazon Rekognition Custom Labels (SDK)](#rm-stop-sdk). ------ 1. Escolha o nome do seu projeto na parte superior da página para voltar à página de visão geral do projeto. 1. Na seção **Modelo**, verifique o status do modelo. O modelo foi interrompido quando o status do modelo é **INTERROMPIDO**. ## Como interromper um modelo do Amazon Rekognition Custom Labels (SDK) Você interrompe um modelo chamando a [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API e passando o Amazon Resource Name (ARN) do modelo no parâmetro de `ProjectVersionArn` entrada. Um modelo pode demorar um pouco para parar. Para verificar o status atual, chame `DescribeProjectVersions`. **Para interromper um modelo (SDK)** 1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md). 1. Use o código de exemplo a seguir para interromper um modelo em execução. ------ #### [ CLI ] Altere o valor de `project-version-arn` para o ARN da versão do modelo que você deseja interromper. ``` aws rekognition stop-project-version --project-version-arn "model arn" \ --profile custom-labels-access ``` ------ #### [ Python ] O exemplo a seguir interrompe um modelo que já está em execução. Forneça os seguintes parâmetros de linha de comando: + `project_arn`: o ARN do projeto que contém o modelo que você deseja interromper. + `model_arn`: o ARN do modelo que você deseja interromper. ``` # 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 ] Forneça os seguintes parâmetros de linha de comando: + `project_arn`: o ARN do projeto que contém o modelo que você deseja interromper. + `model_arn`: o ARN do modelo que você deseja interromper. ``` /* 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: " + " \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); } } } ``` ------ # Duração do relatório de execução e unidades de inferência usadas Se você treinou e iniciou seu modelo depois de agosto de 2022, pode usar a CloudWatch métrica da `InServiceInferenceUnits` Amazon para determinar por quantas horas um modelo foi executado e o número de [unidades de inferência](running-model.md#running-model-inference-units) usadas durante essas horas. **nota** Se você tiver apenas um modelo em uma AWS região, também poderá obter o tempo de execução do modelo rastreando chamadas bem-sucedidas de entrada `StartprojectVersion` e `StopProjectVersion` entrada CloudWatch. Essa abordagem não funciona se você executar mais de um modelo na AWS região, pois as métricas não incluem informações sobre o modelo. Como alternativa, você pode usar AWS CloudTrail para rastrear chamadas para `StartProjectVersion` e `StopProjectVersion` (o que inclui o ARN do modelo no `requestParameters` campo do [histórico de eventos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html?icmpid=docs_console_unmapped)). CloudTrail os eventos são limitados a 90 dias, mas você pode armazenar eventos por até 7 anos em um [CloudTraillago](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html). O procedimento a seguir cria gráficos para o seguinte: + O número de horas em que um modelo foi executado. + O número de unidades de inferência que um modelo usou. É possível escolher um período de até 15 meses no passado. Para obter mais informações sobre a retenção de métricas, consulte [Retenção de métricas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#metrics-retention). **Para determinar a duração do modelo e as unidades de inferência usadas para um modelo** 1. Faça login no Console de gerenciamento da AWS e abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação esquerdo, escolha **Todas as métricas** em **Métricas**. 1. No painel inferior, escolha a guia **Origem**. 1. Certifique-se de que o botão **Painel** está selecionado. 1. Na caixa de edição, substitua o JSON existente pelo JSON a seguir. Altere os seguintes valores: + `Project_Name`: o projeto que contém o modelo que você deseja representar graficamente. + `Version_Name`: a versão do modelo que você deseja representar graficamente. + `AWS_Region`— A AWS região que contém o modelo. Verifique se o CloudWatch console está na mesma AWS região, verificando o seletor de região na barra de navegação na parte superior da página. Atualize conforme for necessário. ``` { "sparkline": true, "metrics": [ [ { "expression": "SUM(m1)*m1", "label": "Inference units used", "id": "e1" } ], [ { "expression": "DATAPOINT_COUNT(m1)*m1/m1", "label": "Hours running", "id": "e2" } ], [ "AWS/Rekognition", "InServiceInferenceUnits", "ProjectName", "Project_Name", "VersionName", "Version_Name", { "id": "m1", "visible": false } ] ], "view": "singleValue", "stacked": false, "region": "AWS_Region", "stat": "Average", "period": 3600, "title": "Hours run and inference units used" } ``` 1. Selecione **Atualizar**. 1. Na parte superior da página, escolha uma linha do tempo. É preciso ver os números das unidades de inferência usadas e as horas de execução durante a linha do tempo. As lacunas no gráfico indicam momentos em que o modelo não estava em execução. A captura de tela do console abaixo mostra as unidades de inferência usadas e as horas de execução ao longo de períodos, com um tempo personalizado de 2 semanas definido e os valores mais altos de 214 unidades de inferência e 209 horas de execução. ![\[Gráfico mostrando as unidades de inferência.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/customlabels-dg/images/model-duration.png) 1. (Opcional) Adicione o gráfico a um painel, selecione **Ações** e **Adicionar ao painel: aprimorado**.