Como excluir um modelo (console)Como excluir um modelo (SDK)

Como excluir um modelo do Amazon Rekognition Custom Labels

É possível excluir um modelo usando o console do Amazon Rekognition Custom Labels ou usando a API DeleteProjectVersion. Não é possível excluir um modelo se ele estiver em execução ou em treinamento. Para interromper um modelo em execução, use a API StopProjectVersion. Para obter mais informações, consulte Como interromper um modelo do Amazon Rekognition Custom Labels (SDK). Se um modelo estiver sendo treinado, espere até que ele termine antes de excluí-lo.

Um modelo excluído não pode ser recuperado.

Tópicos

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

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

O procedimento a seguir mostra como excluir um modelo de uma página de detalhes do projeto. Também é possível excluir um modelo da página de detalhes de um modelo.

Para excluir um canal (console)

Abra o console do Amazon Rekognition em https://console.aws.amazon.com/rekognition/.
Escolha Usar rótulos personalizados.
Escolha Como começar.
No painel de navegação esquerdo, selecione Projetos.
Selecione o tópico que contém o modelo que você deseja excluir. A página de detalhes do projeto é aberta.
Na seção Modelos, escolha os modelos que deseja excluir.

nota
Se o modelo não puder ser selecionado, ele está em execução ou em treinamento e não pode ser excluído. Verifique o campo Status e tente novamente após interromper o modelo em execução ou espere até que o treinamento termine.
Escolha Excluir modelo e a caixa de diálogo Excluir modelo será exibida.
Insira excluir para confirmar a exclusão.
Escolha Delete (Excluir) para excluir o modelo. A exclusão do modelo pode demorar um pouco para ser concluída.

nota
Se Fechar a caixa de diálogo durante a exclusão do modelo, os modelos ainda serão excluídos.

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

É possível excluir um modelo do Amazon Rekognition Custom Labels ao chamar DeleteProjectVersion e fornecer o nome do recurso da Amazon (ARN) do modelo que deseja excluir. É possível obter o ARN do modelo na seção Use seu modelo da página de detalhes do modelo no console do Amazon Rekognition Custom Labels. Como alternativa, chame DescribeProjectVersions e forneça o seguinte.

O ARN do projeto (ProjectArn) ao qual o trabalho está associado.
O nome da versão (VersionNames) do modelo.

O ARN do modelo é o campo ProjectVersionArn no objeto ProjectVersionDescription, da resposta DescribeProjectVersions.

Não é possível excluir um modelo se ele estiver em execução ou em treinamento. Para determinar se o modelo está em execução ou em treinamento, chame DescribeProjectVersions e verifique o campo Status do objeto ProjectVersionDescription do modelo. Para interromper um modelo em execução, use a API StopProjectVersion. Para obter mais informações, consulte Como interromper um modelo do Amazon Rekognition Custom Labels (SDK). É preciso esperar que um modelo termine o treinamento antes de excluí-lo.

Para excluir um modelo (SDK)

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

Use o código a seguir para excluir um modelo.

AWS CLI

Altere o valor de project-version-arn para o nome do projeto que você deseja excluir.


aws rekognition delete-project-version --project-version-arn model_arn \
  --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 excluir.
model_arn: o ARN da versão do modelo que você deseja excluir.


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

"""
Purpose
Shows how to delete an existing Amazon Rekognition Custom Labels model.
"""


import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)


def find_forward_slash(input_string, n):
    """
    Returns the location of '/' after n number of occurences. 
    :param input_string: The string you want to search
    : n: the occurence that you want to find.
    """
    position = input_string.find('/')
    while position >= 0 and n > 1:
        position = input_string.find('/', position + 1)
        n -= 1
    return position


def delete_model(rek_client, project_arn, model_arn):
    """
    Deletes an Amazon Rekognition Custom Labels model.
    :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
    :param model_arn: The ARN of the model version that you want to delete.
    """

    try:
        # Delete the model
        logger.info("Deleting dataset: {%s}", model_arn)

        rek_client.delete_project_version(ProjectVersionArn=model_arn)

        # Get the model version name
        start = find_forward_slash(model_arn, 3) + 1
        end = find_forward_slash(model_arn, 4)
        version_name = model_arn[start:end]

        deleted = False

        # model might not be deleted yet, so wait deletion finishes.
        while deleted is False:
            describe_response = rek_client.describe_project_versions(ProjectArn=project_arn,
                                                                     VersionNames=[version_name])
            if len(describe_response['ProjectVersionDescriptions']) == 0:
                deleted = True
            else:
                logger.info("Waiting for model deletion %s", model_arn)
                time.sleep(5)

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

        return True

    except ClientError as err:
        logger.exception("Couldn't delete 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 delete."
    )

    parser.add_argument(
        "model_arn", help="The ARN of the model version that you want to delete."
    )


def confirm_model_deletion(model_arn):
    """
    Confirms deletion of the model. Returns True if delete entered.
    :param model_arn: The ARN of the model that you want to delete.
    """
    print(f"Are you sure you wany to delete model {model_arn} ?\n", model_arn)

    start = input("Enter delete to delete your model: ")
    if start == "delete":
        return True
    else:
        return 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()

        if confirm_model_deletion(args.model_arn) is True:
            print(f"Deleting model: {args.model_arn}")

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

            delete_model(rekognition_client,
                         args.project_arn,
                         args.model_arn)

            print(f"Finished deleting model: {args.model_arn}")
        else:
            print(f"Not deleting model {args.model_arn}")

    except ClientError as err:
        print(f"Problem deleting model: {err}")


if __name__ == "__main__":
    main()

Java V2

project_arn: o ARN do projeto que contém o modelo que você deseja excluir.
model_arn: o ARN da versão do modelo que você deseja excluir.


//Copyright 2021 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 java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;

import software.amazon.awssdk.services.rekognition.RekognitionClient;

import software.amazon.awssdk.services.rekognition.model.DeleteProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.DeleteProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;

public class DeleteModel {

    public static final Logger logger = Logger.getLogger(DeleteModel.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 deleteMyModel(RekognitionClient rekClient, String projectArn, String modelArn)
            throws InterruptedException {

        try {

            logger.log(Level.INFO, "Deleting model: {0}", projectArn);

            // Delete the model

            DeleteProjectVersionRequest deleteProjectVersionRequest = DeleteProjectVersionRequest.builder()
                    .projectVersionArn(modelArn).build();

            DeleteProjectVersionResponse response =
                    rekClient.deleteProjectVersion(deleteProjectVersionRequest);

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

            // Get the model version

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

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

            Boolean deleted = false;

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

            // Wait until model is deleted.

            do {

                DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
                        .describeProjectVersions(describeProjectVersionsRequest);

                if (describeProjectVersionsResponse.projectVersionDescriptions().size()==0) {
                    logger.log(Level.INFO, "Waiting for model deletion: {0}", modelArn);
                    Thread.sleep(5000);
                } else {
                    deleted = true;
                    logger.log(Level.INFO, "Model deleted: {0}", modelArn);
                }
                
            } while (Boolean.FALSE.equals(deleted));

            logger.log(Level.INFO, "Model deleted: {0}", modelArn);

        } catch (

        RekognitionException e) {
            logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
            throw e;
        }

    }

    public static void main(String args[]) {

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

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

        String projectArn = args[0];
        String modelVersion = args[1];

        try {

            RekognitionClient rekClient = RekognitionClient.builder().build();

            // Delete the model
            deleteMyModel(rekClient, projectArn, modelVersion);

            System.out.println(String.format("model deleted: %s", modelVersion));

            rekClient.close();

        } catch (RekognitionException rekError) {
            logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
            System.exit(1);
        }

        catch (InterruptedException intError) {
            logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.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 gerenciar um modelo

Como marcar um modelo