Treinamento de seu modelo - Amazon Lookout for Vision
Treinando um modelo (console)Treinando um modelo (SDK)

Aviso de fim do suporte: em 31 de outubro de 2025, o suporte para o Amazon Lookout for Vision AWS será interrompido. Depois de 31 de outubro de 2025, você não poderá mais acessar o console do Lookout for Vision ou os recursos do Lookout for Vision. Para obter mais informações, visite esta postagem do blog.

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á.

Treinamento de seu modelo

Depois de criar seus conjuntos de dados e rotular as imagens, você pode treinar seu modelo. Como parte do processo de treinamento, um conjunto de dados de teste é usado. Se você tiver um único projeto de conjunto de dados, as imagens no conjunto de dados serão automaticamente divididas em um conjunto de dados de teste e um conjunto de dados de treinamento como parte do processo de treinamento. Se seu projeto tiver um conjunto de dados de treinamento e um conjunto de dados de teste, eles serão usados para treinar e testar separadamente o conjunto de dados.

Depois que o treinamento for concluído, você poderá avaliar o desempenho do modelo e fazer as melhorias necessárias. Para obter mais informações, consulte Melhoria de um modelo do Amazon Lookout for Vision.

Para treinar seu modelo, o Amazon Lookout for Vision faz uma cópia das imagens originais de treinamento e teste. Por padrão, as imagens copiadas são criptografadas com uma chave que AWS possui e gerencia. Você também pode optar por usar sua própria AWS chave Key Management Service (KMS). Para obter mais informações, consulte Conceitos do AWS Key Management Service. Suas imagens de origem não são afetadas.

Você pode atribuir metadados ao seu modelo na forma de tags. Para obter mais informações, consulte Modelos de marcação.

Cada vez que você treina um modelo, uma nova versão do modelo é criada. Se você não precisar mais de uma versão de um modelo, poderá excluí-la. Para obter mais informações, consulte Excluir um modelo.

Você será cobrado pelo tempo necessário para treinar o modelo com sucesso. Para obter mais informações, consulte Horas de treinamento.

Para visualizar os modelos existentes em um projeto, Visualizar as modelos.

nota

Se você acabou de concluir Criar um conjunto de dados ouAdicionar imagens ao seu conjunto de dados. No momento, o console deve mostrar o painel do seu modelo e você não precisa seguir as etapas 1 a 4.

Treinando um modelo (console)

O procedimento a seguir mostra como treinar o modelo usando o console.

Para treinar seu modelo (console)

  1. Abra o console https://console.aws.amazon.com/lookoutvision/Amazon Lookout for Vision em.

  2. No painel de navegação à esquerda, escolha Projetos.

  3. Na página Projetos, escolha o projeto que contém o modelo que você deseja treinar.

  4. Na página de detalhes do projeto, escolha Modelo de trem. O botão Treinar modelo está disponível se você tiver imagens rotuladas suficientes para treinar o modelo. Se o botão não estiver disponível, adicione mais imagens até que você tenha imagens rotuladas suficientes.

  5. (Opcional) Se você quiser usar sua própria chave de AWS KMS criptografia, faça o seguinte:

    1. Em Criptografia de dados de imagem, escolha Personalizar configurações de criptografia (avançado).

    2. Em encryption.aws_kms_key, insira o Amazon Resource Name ARN () da sua chave ou escolha uma chave existente. AWS KMS Para criar uma nova chave, escolha Criar uma AWS IMS chave.

  6. (Opcional) se quiser adicionar tags ao seu modelo, faça o seguinte:

    1. Na seção Tags, escolha Adicionar nova tag.

    2. Insira o seguinte:

      1. O nome da chave em Chave.

      2. O valor da chave em Valor.

    3. Para adicionar mais tags, repita as etapas 6a e 6b.

    4. (Opcional) Se deseja remover uma tag, selecione Remover ao lado da tag que você deseja remover. Se você estiver removendo uma tag salva anteriormente, ela será removida quando você salvar suas alterações.

  7. Escolha o modelo do trem.

  8. Na caixa de diálogo Você quer treinar seu modelo?, escolha Treinar modelo.

  9. Na visualização Modelos, você pode ver que o treinamento foi iniciado e verificar o status atual visualizando a Status coluna da versão do modelo. O treinamento de um modelo leva algum tempo para ser concluído.

  10. Quando o treinamento terminar, você poderá avaliar seu desempenho. Para obter mais informações, consulte Melhoria de um modelo do Amazon Lookout for Vision.

Treinando um modelo (SDK)

Você usa a CreateModeloperação para iniciar o treinamento, o teste e a avaliação de um modelo. O Amazon Lookout for Vision treina o modelo usando o conjunto de dados de treinamento e teste associado ao projeto. Para obter mais informações, consulte Criando um projeto (SDK).

Toda vez que você chama CreateModel, uma nova versão do modelo é criada. A resposta de CreateModel inclui a versão do modelo.

Você é cobrado por cada modelo de treinamento bem-sucedido. Use o parâmetro ClientToken de entrada para ajudar a evitar cobranças devido a repetições desnecessárias ou acidentais do treinamento de modelos por seus usuários. ClientToken é um parâmetro de entrada idempotente que garante que CreateModel seja concluído apenas uma vez para um conjunto específico de parâmetros. Uma chamada repetida de CreateModel com o mesmo valor ClientToken garante que o treinamento não seja repetido. Se você não fornecer um valor paraClientToken, o AWS SDK que você está usando insere um valor para você. Isso evita que novas tentativas após um erro de rede iniciem vários trabalhos de treinamento, mas você precisará fornecer seu próprio valor para seus próprios casos de uso. Para obter mais informações, consulte CreateModel.

O treinamento demora um pouco para ser concluído. Para verificar o status atual, chame DescribeModel e passe o nome do projeto (especificado na chamada paraCreateProject) e a versão do modelo. O status campo indica o status atual do treinamento do modelo. Para ver um código demonstrativo, consulte Visualizando seus modelos (SDK).

Se o treinamento for bem-sucedido, você poderá avaliar o modelo. Para obter mais informações, consulte Melhoria de um modelo do Amazon Lookout for Vision.

Para ver os modelos que você criou em um projeto, chame ListModels. Para ver um código demonstrativo, consulte Visualizar as modelos.

Para treinar 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.

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

    CLI

    Altere os seguintes valores:

    • project-name ao nome do projeto que contém o modelo que você deseja criar.

    • output-config para o local onde você deseja salvar os resultados do treinamento. Substitua os valores a seguir:

      • output bucket com o nome do bucket do Amazon S3 em que o Amazon Lookout for Vision salva os resultados do treinamento.

      • output folder com o nome da pasta onde deseja salvar os resultados do treinamento.

      • Key com o nome de uma chave de tag.

      • Valuecom um valor ao qual associartag_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

    Esse código foi retirado do GitHub repositório de SDK exemplos de AWS documentação. Veja o exemplo completo aqui. 

        @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

    Esse código foi retirado do GitHub repositório de SDK exemplos de AWS documentação. Veja o exemplo completo aqui. 

    /**
 * 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. Quando o treinamento terminar, você poderá avaliar seu desempenho. Para obter mais informações, consulte Melhoria de um modelo do Amazon Lookout for Vision.