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 treinar um modelo do Amazon Rekognition Custom Labels
É possível treinar um modelo usando o console do Amazon Rekognition Custom Labels ou pela API Amazon Rekognition Custom Labels. Se o treinamento do modelo falhar, use as informações em Como depurar um treinamento de modelo em falha para encontrar a causa da falha.
Há uma cobrança pelo tempo necessário para treinar um modelo com êxito. Normalmente, o treinamento leva de 30 minutos a 24 horas para ser concluído. Para obter mais informações, consulte Horas de treinamento.
Uma nova versão de um modelo é criada toda vez que ele é treinado. O Amazon Rekognition Custom Labels cria um nome para o modelo que é uma combinação do nome do projeto e do timestamp de quando o modelo foi criado.
Para treinar seu modelo, o Amazon Rekognition Custom Labels faz uma cópia das imagens originais de treinamento e teste. Por padrão, as imagens copiadas são criptografadas em repouso com uma chave que a AWS possui e gerencia. Também é possível optar por usar a sua própria AWS KMS key. Se usa sua própria chave do KMS, precisará das permissões a seguir na chave do KMS.
kms: CreateGrant
kms: DescribeKey
Para obter mais informações, consulte Conceitos do AWS Key Management Service. Suas imagens de origem não são afetadas.
É possível usar a criptografia do lado do servidor (SSE-KMS) para criptografar as imagens de treinamento e teste em seu bucket do Amazon S3, antes de serem copiadas pelo Amazon Rekognition Custom Labels. Para permitir que as etiquetas personalizadas do Amazon Rekognition acessem suas imagens AWS , sua conta precisa das seguintes permissões na chave KMS.
kms: GenerateDataKey
kms:Decrypt
Para obter mais informações, consulte Como proteger dados usando criptografia do lado do servidor com chaves KMS armazenadas no AWS Key Management Service (SSE-KMS).
Depois de treinar um modelo, é possível avaliar seu desempenho e fazer melhorias. Para ter mais informações, consulte Como melhorar um modelo treinado do Amazon Rekognition Custom Labels.
Para outras tarefas do modelo, como atribuir tag a um modelo, consulte Como gerenciar um modelo do Amazon Rekognition Custom Labels.
Como treinar um modelo (console)
É possível usar o console do Amazon Rekognition Custom Labels para treinar um modelo.
O treinamento requer um conjunto de dados de treinamento e um conjunto de dados de teste. Se seu projeto não tiver um conjunto de dados de teste, o console do Amazon Rekognition Custom Labels divide o conjunto de dados de treinamento durante o treinamento para criar um para seu projeto. As imagens escolhidas são uma amostra representativa e não são usadas no conjunto de dados de treinamento. É recomendável dividir seu conjunto de dados de treinamento somente se não tiver um conjunto de dados de teste alternativo que possa usar. A divisão de um conjunto de dados de treinamento reduz o número de imagens disponíveis para treinamento.
Há uma cobrança pelo tempo necessário para treinar um modelo. Para obter mais informações, consulte Horas de treinamento.
Para treinar seu modelo (console)
Abra o console do Amazon Rekognition em https://console.aws.amazon.com/rekognition/.
Escolha Usar rótulos personalizados.
No painel de navegação esquerdo, selecione Projetos.
Na página Projetos, escolha o projeto que contém o modelo que deseja treinar.
Na página Projeto, escolha Treinar modelo.
(Opcional) Se você quiser usar sua própria chave de criptografia do AWS KMS, faça o seguinte:
Em Criptografia de dados de imagem, escolha Personalizar configurações de criptografia (avançado).
Em encryption.aws_kms_key, insira o nome do recurso da Amazon (ARN) da sua chave ou escolha uma chave do AWS KMS existente. Para criar uma nova chave, escolha Criar uma chave do AWS IMS.
(Opcional) se quiser adicionar tags ao seu modelo, faça o seguinte:
Na seção Tags, escolha Adicionar nova tag.
Insira o seguinte:
O nome da chave em Chave.
O valor da chave em Valor.
Para adicionar mais tags, repita as etapas 6a e 6b.
(Opcional) Se deseja remover uma tag, selecione Remover ao lado da tag que você deseja remover. Se estiver removendo uma tag salva anteriormente, ela será removida quando você salvar suas alterações.
Na página Treinar modelo, escolha Treinar modelo. O nome do recurso da Amazon (ARN) do seu projeto deve estar na caixa de edição Escolher projeto. Caso contrário, insira o ARN do seu projeto.
Na caixa de diálogo Você quer treinar seu modelo?, escolha Treinar modelo.
Na seção Modelos da página do projeto, pode verificar o status atual na coluna Model Status, onde o treinamento está em andamento. O treinamento de um modelo demora para ser concluído.
Após a conclusão do treinamento, escolha o nome do modelo. O treinamento é concluído quando o status do modelo for TRAINING_COMPLETED. Se o treinamento falhar, leia Como depurar um treinamento de modelo em falha.
Próxima etapa: avalie seu modelo. Para obter mais informações, Como melhorar um modelo treinado do Amazon Rekognition Custom Labels.
Treinando um modelo (SDK)
Você treina um modelo ligando CreateProjectVersion. Para treinar um modelo, as seguintes informações são necessárias:
Nome: um nome exclusivo para a versão do modelo.
ARN do projeto: o nome do recurso da Amazon (ARN) do projeto que gerencia o modelo.
Local dos resultados do treinamento: o local do Amazon S3 em que os resultados são colocados. É possível usar o mesmo local do bucket do console do Amazon S3 ou escolher um local diferente. A recomendação é escolher um local diferente, pois isso permite a definição de permissões e evitar possíveis conflitos de nomenclatura com os resultados do treinamento do uso do console do Amazon Rekognition Custom Labels.
O treinamento usa os conjuntos de dados de treinamento e teste associados ao projeto. Para ter mais informações, consulte Como gerenciar conjuntos de dados.
Você tem a opção de especificar arquivos de manifesto do conjunto de dados de treinamento e teste que são externos a um projeto. Se abrir o console após treinar um modelo com arquivos de manifesto externos, o Amazon Rekognition Custom Labels criará os conjuntos de dados para você usando o último conjunto de arquivos de manifesto usado para treinamento. Não é mais possível treinar uma versão de modelo para o projeto especificando arquivos de manifesto externos. Para obter mais informações, consulte CreatePrjectVersion.
A resposta de CreateProjectVersion é um ARN que você usa para identificar a versão do modelo em solicitações subsequentes. Também é possível usar o ARN para proteger a versão do modelo. Para ter mais informações, consulte Como proteger projetos do Amazon Rekognition Custom Labels.
O treinamento de uma versão do modelo demora para ser concluído. Os exemplos em Python e Java neste tópico usam esperadores para aguardar a conclusão do treinamento. Um agentes de espera é um métodos utilitário que sonda um determinado estado para verificar se ele ocorreu em um cliente. Como alternativa, é possível obter o status atual do treinamento ao chamar DescribeProjectVersions. O treinamento é concluído quando o valor do campo Status for TRAINING_COMPLETED. Depois que o treinamento for concluído, será possível avaliar a qualidade do modelo analisando os resultados da avaliação.
Como treinar um modelo (SDK)
O exemplo a seguir mostra como treinar um modelo usando os conjuntos de dados de treinamento e teste associados a um projeto.
Para treinar 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 os AWS SDKs AWS CLI e.
Use o código de exemplo a seguir para treinar um projeto.
- AWS CLI
-
O exemplo a seguir cria um modelo. O conjunto de dados de treinamento é dividido para criar o conjunto de dados de teste. Substitua o seguinte:
-
my_project_arn com o nome do recurso da Amazon (ARN) do projeto.
-
version_name com um nome exclusivo de versão de sua escolha.
-
output_bucket com o nome do bucket do Amazon S3 no qual o Amazon Rekognition Custom Labels salva os resultados do treinamento.
-
output_folder com o nome da pasta em que os resultados do treinamento são salvos.
(parâmetro opcional) --kms-key-id com identificador para sua chave mestra de cliente do AWS Key Management Service.
aws rekognition create-project-version \
--project-arn project_arn \
--version-name version_name \
--output-config '{"S3Bucket":"output_bucket", "S3KeyPrefix":"output_folder"}' \
--profile custom-labels-access
- Python
-
O exemplo a seguir cria um modelo. Forneça os seguintes argumentos de linha de comando:
project_arn: o nome do recurso da Amazon (ARN) do projeto.
version_name: um nome exclusivo de versão para o modelo de sua escolha.
output_bucket: o nome do bucket do Amazon S3 no qual o Amazon Rekognition Custom Labels salva os resultados do treinamento.
output_folder: o nome da pasta em que os resultados do treinamento são salvos.
Você tem a opção de fornecer os seguintes parâmetros de linha de comando para anexar uma tag ao seu modelo:
#Copyright 2023 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 argparse
import logging
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def train_model(rek_client, project_arn, version_name, output_bucket, output_folder, tag_key, tag_key_value):
"""
Trains an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to train a model.
:param version_name: A version for the model.
:param output_bucket: The S3 bucket that hosts training output.
:param output_folder: The path for the training output within output_bucket
:param tag_key: The name of a tag to attach to the model. Pass None to exclude
:param tag_key_value: The value of the tag. Pass None to exclude
"""
try:
#Train the model
status=""
logger.info("training model version %s for project %s",
version_name, project_arn)
output_config = json.loads(
'{"S3Bucket": "'
+ output_bucket
+ '", "S3KeyPrefix": "'
+ output_folder
+ '" } '
)
tags={}
if tag_key is not None and tag_key_value is not None:
tags = json.loads(
'{"' + tag_key + '":"' + tag_key_value + '"}'
)
response=rek_client.create_project_version(
ProjectArn=project_arn,
VersionName=version_name,
OutputConfig=output_config,
Tags=tags
)
logger.info("Started training: %s", response['ProjectVersionArn'])
# Wait for the project version training to complete.
project_version_training_completed_waiter = rek_client.get_waiter('project_version_training_completed')
project_version_training_completed_waiter.wait(ProjectArn=project_arn,
VersionNames=[version_name])
# Get the completion status.
describe_response=rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in describe_response['ProjectVersionDescriptions']:
logger.info("Status: %s", model['Status'])
logger.info("Message: %s", model['StatusMessage'])
status=model['Status']
logger.info("finished training")
return response['ProjectVersionArn'], status
except ClientError as err:
logger.exception("Couldn't create model: %s", 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 in which you want to train a model"
)
parser.add_argument(
"version_name", help="A version name of your choosing."
)
parser.add_argument(
"output_bucket", help="The S3 bucket that receives the training results."
)
parser.add_argument(
"output_folder", help="The folder in the S3 bucket where training results are stored."
)
parser.add_argument(
"--tag_name", help="The name of a tag to attach to the model", required=False
)
parser.add_argument(
"--tag_value", help="The value for the tag.", 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()
print(f"Training model version {args.version_name} for project {args.project_arn}")
# Train the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
model_arn, status=train_model(rekognition_client,
args.project_arn,
args.version_name,
args.output_bucket,
args.output_folder,
args.tag_name,
args.tag_value)
print(f"Finished training model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
except Exception as err:
logger.exception("Problem training model: %s", err)
print(f"Problem training model: {err}")
if __name__ == "__main__":
main()
- Java V2
-
O exemplo a seguir treina um modelo. Forneça os seguintes argumentos de linha de comando:
project_arn: o nome do recurso da Amazon (ARN) do projeto.
version_name: um nome exclusivo de versão para o modelo de sua escolha.
output_bucket: o nome do bucket do Amazon S3 no qual o Amazon Rekognition Custom Labels salva os resultados do treinamento.
output_folder: o nome da pasta em que os resultados do treinamento são salvos.
/*
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.CreateProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TrainModel {
public static final Logger logger = Logger.getLogger(TrainModel.class.getName());
public static String trainMyModel(RekognitionClient rekClient, String projectArn, String versionName,
String outputBucket, String outputFolder) {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
logger.log(Level.INFO, "Training Model for project {0}", projectArn);
CreateProjectVersionRequest createProjectVersionRequest = CreateProjectVersionRequest.builder()
.projectArn(projectArn).versionName(versionName).outputConfig(outputConfig).build();
CreateProjectVersionResponse response = rekClient.createProjectVersion(createProjectVersionRequest);
logger.log(Level.INFO, "Model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Training model...");
// wait until training completes
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(projectArn)
.build();
RekognitionWaiter waiter = rekClient.waiter();
WaiterResponse<DescribeProjectVersionsResponse> waiterResponse = waiter
.waitUntilProjectVersionTrainingCompleted(describeProjectVersionsRequest);
Optional<DescribeProjectVersionsResponse> optionalResponse = waiterResponse.matched().response();
DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
System.out.println("Status: " + projectVersionDescription.statusAsString());
System.out.println("Message: " + projectVersionDescription.statusMessage());
}
return response.projectVersionArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String versionName = null;
String projectArn = null;
String projectVersionArn = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: " + "<project_name> <version_name> <output_bucket> <output_folder>\n\n" + "Where:\n"
+ " project_arn - The ARN of the project that you want to use. \n\n"
+ " version_name - A version name for the model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
versionName = args[1];
bucket = args[2];
location = args[3];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Train model
projectVersionArn = trainMyModel(rekClient, projectArn, versionName, bucket, location);
System.out.println(String.format("Created model: %s for Project ARN: %s", projectVersionArn, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
Se o treinamento falhar, leia Como depurar um treinamento de modelo em falha.
