Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Addestramento di un modello Amazon Rekognition Custom Labels
Puoi addestrare un modello utilizzando la console di Amazon Rekognition Custom Labels o l'API Amazon Rekognition Custom Labels. Se l'addestramento del modello fallisce, utilizza le informazioni contenute in Eseguire il debug di un modello di addestramento fallito per scoprire la causa dell'errore.
Ti viene addebitato il tempo necessario per addestrare correttamente un modello. In genere, il completamento dell’addestramento richiede da 30 minuti a 24 ore. Per ulteriori informazioni, consulta Ore di addestramento.
Ogni volta che un modello viene addestrato, viene creata una nuova versione del modello. Amazon Rekognition Custom Labels crea un nome per il modello che è una combinazione del nome del progetto e del timestamp di creazione del modello.
Per addestrare il tuo modello, Amazon Rekognition Custom Labels crea una copia delle immagini di addestramento e di test di origine. Per impostazione predefinita, le immagini copiate sono crittografate quando sono inattive con una chiave posseduta e gestita da AWS. Puoi anche decidere di utilizzare il tuo AWS KMS key. Se utilizzi la tua chiave KMS, hai bisogno delle seguenti autorizzazioni per la chiave KMS.
km: CreateGrant
km: DescribeKey
Per ulteriori informazioni, consulta Concetti di AWS Key Management Service. Le tue immagini di origine non vengono modificate.
Puoi utilizzare la crittografia lato server KMS (SSE-KMS) per crittografare le immagini di addestramento e di test nel tuo bucket Amazon S3, prima che vengano copiate da Amazon Rekognition Custom Labels. Per consentire ad Amazon Rekognition Custom Labels di accedere alle tue immagini AWS , il tuo account necessita delle seguenti autorizzazioni sulla chiave KMS.
km: GenerateDataKey
kms:Decrypt
Per maggiori informazioni, consulta Protezione dei dati con la crittografia lato server con chiavi KMS memorizzate in AWS Key Management Service (SSE-KMS).
Dopo aver addestrato un modello, puoi valutarne le prestazioni e apportare miglioramenti. Per ulteriori informazioni, consulta Miglioramento di un modello Amazon Rekognition Custom Labels addestrato.
Per altre attività relative al modello, come il tagging di un modello, consulta Gestione di un modello di Amazon Rekognition Custom Labels.
Addestramento di un modello (Console)
Puoi utilizzare la console di Amazon Rekognition Custom Labels per addestrare un modello.
L’addestramento richiede un progetto con un set di dati di addestramento e un set di dati di test. Se il tuo progetto non ha un set di dati di test, la console di Amazon Rekognition Custom Labels suddivide il set di dati di addestramento durante l'addestramento per crearne uno per il tuo progetto. Le immagini scelte sono un campione rappresentativo e non vengono utilizzate nel set di dati di addestramento. Ti consigliamo di suddividere il set di dati di addestramento solo se non disponi di un set di dati di test alternativo da utilizzare. La suddivisione di un set di dati di addestramento riduce il numero di immagini disponibili per addestramento.
Ti viene addebitato il tempo necessario per addestrare un modello. Per ulteriori informazioni, consulta Ore di addestramento.
Per addestrare il tuo modello (console)
Apri la console Amazon Rekognition all'indirizzo https://console.aws.amazon.com/rekognition/.
Scegli Usa etichette personalizzate.
Nel pannello di navigazione a sinistra, scegli Progetti.
Nella pagina Progetti, scegli il progetto che contiene il modello che desideri addestrare.
Nella pagina Progetti, scegli Addestra modello.
(Facoltativo) Se desideri utilizzare la tua chiave di crittografia AWS KMS, procedi come segue:
In Crittografia dei dati di immagine scegli Personalizza le impostazioni (avanzate) di crittografia.
In encryption.aws_kms_key inserisci l'Amazon Resource Name (ARN) della tua chiave o scegli una chiave AWS KMS esistente. Per creare una nuova chiave, scegli Crea una chiave AWS IMS.
(Facoltativo) Se desideri aggiungere tag al modello, procedi come segue:
Nella sezione Tag, seleziona Aggiungi nuovo tag.
Immetti i seguenti dati:
Il nome della chiave in Chiave.
Il valore della chiave in Valore.
Per aggiungere altri tag, ripeti i passaggi 6a e 6b.
(Facoltativo) Se desideri rimuovere un tag, scegli Rimuovi accanto al tag da rimuovere. Se stai rimuovendo un tag salvato in precedenza, questo viene rimosso quando salvi le modifiche.
Nella pagina Addestra modello, scegli Addestra modello. L'Amazon Resource Name (ARN) del progetto deve trovarsi nella casella di modifica Scegli progetto. In caso contrario, inserisci l'ARN per il tuo progetto.
Nella finestra di dialogo Vuoi addestrare il tuo modello?, scegli Addestra modello.
Nella sezione Modelli della pagina del progetto, puoi controllare lo stato attuale nella colonna Model Status
in cui è in corso l’addestramento. L'addestramento di un modello richiede tempo.
Al termine dell'addestramento, scegli il nome del modello. L'addestramento è terminato quando lo stato del modello è ADDESTRAMENTO_COMPLETATO. Se l'addestramento fallisce, consulta Eseguire il debug di un modello di addestramento fallito.
Passaggio successivo: valuta il tuo modello. Per ulteriori informazioni, consulta Miglioramento di un modello Amazon Rekognition Custom Labels addestrato.
Addestramento di un modello (SDK)
Si addestra un modello chiamando. CreateProjectVersion Per addestrare un modello, sono necessarie le seguenti informazioni:
Nome – un nome univoco per la versione del modello.
ARN di progetto – l'Amazon Resource Name (ARN) del progetto che gestisce il modello.
Posizione dei risultati dell’addestramento – la posizione di Amazon S3 in cui sono memorizzati i risultati. Puoi utilizzare la stessa posizione del bucket Amazon S3 della console oppure puoi scegliere una posizione diversa. Ti consigliamo di scegliere una posizione diversa perché ciò consente di impostare le autorizzazioni ed evitare potenziali conflitti di denominazione con i risultati di addestramento derivanti dall'utilizzo della console di Amazon Rekognition Custom Labels.
L’addestramento utilizza i set di dati di addestramento e di test associati al progetto. Per ulteriori informazioni, consulta Gestione di set di dati.
Facoltativamente, è possibile specificare file manifest dei set di dati di addestramento e di test esterni a un progetto. Se apri la console dopo aver addestrato un modello con file manifest esterni, Amazon Rekognition Custom Labels crea i set di dati per te utilizzando l'ultimo set di file manifest utilizzato per l’addestramento. Non puoi più addestrare una versione del modello per il progetto specificando file manifest esterni. Per ulteriori informazioni, vedere CreatePrjectVersion.
La risposta di CreateProjectVersion
è un ARN utilizzato per identificare la versione del modello nelle richieste successive. Puoi anche utilizzare l'ARN per proteggere la versione del modello. Per ulteriori informazioni, consulta Protezione dei progetti Amazon Rekognition Custom Labels.
Il completamento dell'addestramento di una versione del modello richiede tempo. Gli esempi Python e Java in questo argomento utilizzano waiter per attendere il completamento della addestramento. Un waiter è un metodo di utility che esegue il polling per il verificarsi di uno stato particolare. In alternativa, puoi conoscere lo stato attuale della addestramento chiamando DescribeProjectVersions
. L'addestramento è completato quando il valore del campo Status
diventa TRAINING_COMPLETED
. Una volta completato l’addestramento, è possibile valutare la qualità del modello esaminando i risultati di valutazione.
Addestramento di un modello (SDK)
L'esempio seguente mostra come addestrare un modello utilizzando i set di dati di addestramento e di test associati a un progetto.
Per addestrare modello (SDK)
-
Se non l'hai ancora fatto, installa e configura gli AWS CLI AWS SDK. Per ulteriori informazioni, consulta Passaggio 4: configura il AWS CLI e AWS SDKs.
Utilizza il seguente codice di esempio per addestrare un progetto.
- AWS CLI
-
L'esempio seguente crea un modello. Il set di dati di addestramento viene suddiviso per creare il set di dati di test. Sostituisci quanto segue:
-
my_project_arn
con l’Amazon Resource Name (ARN) del progetto.
-
version_name
con un nome di versione univoco a tua scelta.
-
output_bucket
con il nome del bucket Amazon S3 in cui Amazon Rekognition Custom Labels salva i risultati dell’addestramento.
-
output_folder
con il nome della cartella in cui vengono salvati i risultati dell'addestramento.
(parametro opzionale) --kms-key-id
con identificatore per la chiave master del cliente 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
-
L'esempio seguente crea un modello. Fornisci i seguenti argomenti riga di comando:
project_arn
– l’Amazon Resource Name (ARN) del progetto.
version_name
– un nome di versione univoco per il modello a tua scelta.
output_bucket
– il nome del bucket Amazon S3 in cui Amazon Rekognition Custom Labels salva i risultati dell’addestramento.
output_folder
– il nome della cartella in cui vengono salvati i risultati dell’addestramento.
Facoltativamente, fornisci i seguenti parametri di riga di comando per collegare un tag al modello:
#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
-
L'esempio seguente addestra un modello. Fornisci i seguenti argomenti riga di comando:
project_arn
– l’Amazon Resource Name (ARN) del progetto.
version_name
– un nome di versione univoco per il modello a tua scelta.
output_bucket
– il nome del bucket Amazon S3 in cui Amazon Rekognition Custom Labels salva i risultati dell’addestramento.
output_folder
– il nome della cartella in cui vengono salvati i risultati dell’addestramento.
/*
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 l'addestramento fallisce, consulta Eseguire il debug di un modello di addestramento fallito.