Procédure d'entraînement incrémentiel (console)Procédure d'entraînement incrémentiel (API)

Utiliser la formation incrémentielle sur Amazon SageMaker

Avec le temps, il se peut que vous constatiez que les inférences générées par un modèle ne sont pas aussi bonnes que par le passé. Avec l'entraînement incrémentiel, vous pouvez utiliser les artefacts à partir d'un modèle existant et utiliser un ensemble de données étendu pour entraîner un nouveau modèle. L'entraînement incrémentiel permet de gagner du temps et des ressources.

Employez l'entraînement incrémentiel pour :

Entraîner un nouveau modèle à l'aide d'un ensemble de données étendu contenant un modèle sous-jacent qui n'était pas pris en compte dans l'entraînement préalable, ce qui provoquait des performances médiocres.
Utiliser tout ou partie des artefacts de modèle d'un modèle populaire publiquement disponible dans une tâche d'entraînement. Vous n'avez pas besoin d'entraîner un nouveau modèle à partir de zéro.
Reprendre une tâche d'entraînement qui a été arrêtée.
Entraîner plusieurs variantes d'un modèle, soit avec des hyperparamètres différents ou des ensembles de données différents.

Pour de plus amples informations sur les tâches d'entraînement, veuillez consulter Entraînez un modèle avec Amazon SageMaker.

Vous pouvez vous entraîner de manière incrémentielle à l'aide de la SageMaker console ou du SDK Amazon SageMaker Python.

Important

Seuls deux algorithmes intégrés prennent actuellement en charge l'entraînement incrémentiel : Détection d'objets : MXNet, Classification des images - MXNet et Algorithme de segmentation sémantique.

Rubriques

Procédure d'entraînement incrémentiel (console)
Procédure d'entraînement incrémentiel (API)

Procédure d'entraînement incrémentiel (console)

Pour réaliser cette procédure, il vous faut :

L'URI de compartiment Amazon Simple Storage Service (Amazon S3) dans lequel vous avez stocké les données d'entraînement.
L'URL du compartiment S3 où vous voulez stocker la sortie de la tâche.
Le chemin d'accès Amazon Elastic Container Registry dans lequel le code d'entraînement est stocké. Pour plus d'informations, consultez Chemins de registre Docker et exemple de code.
L'URL du compartiment S3 dans lequel vous avez stocké les artefacts de modèle que vous souhaitez utiliser dans l'entraînement incrémentiel. Afin de trouver l'URL pour les artefacts de modèle, consultez la page des détails de la tâche d'entraînement utilisée pour créer le modèle. Pour accéder à la page de détails, dans la SageMaker console, choisissez Inference, Models, puis choisissez le modèle.

Pour redémarrer une tâche d'entraînement arrêtée, utilisez l'URL des artefacts du modèle qui sont stockés dans la page des détails, comme vous le feriez avec un modèle ou une tâche d'entraînement terminée.

Pour procéder à l'entraînement incrémentiel (console)

Ouvrez la SageMaker console Amazon à l'adresse https://console.aws.amazon.com/sagemaker/.
Dans le panneau de navigation, choisissez Training (Entraînement), puis Training jobs (Tâches d'entraînement).
Choisissez Create training job (Créer une tâche d'entraînement).
Indiquez un nom pour la tâche d'entraînement. Le nom doit être unique dans une AWS région d'un AWS compte. Le nom de la tâche d'entraînement doit comporter 1 à 63 caractères. Les caractères valides sont a-z, A-Z, 0-9 et . : + = @ _ % - (trait d'union).
Choisissez l'algorithme à utiliser. Pour obtenir des informations sur les algorithmes, consultez Utilisez les algorithmes SageMaker intégrés d'Amazon ou des modèles préentraînés.
(Facultatif) Pour Configuration des ressources, conservez les valeurs par défaut ou augmentez la consommation des ressources afin de réduire le temps de traitement.
1. (Facultatif) Pour Type d'instance, choisissez le type d'instance de calcul ML à utiliser. Dans la plupart des cas, ml.m4.xlarge est suffisant.
2. Pour Nombre d'instances, utilisez la valeur par défaut 1.
3. (Facultatif) Pour Taille du volume par instance (Go), choisissez la taille du volume de stockage ML que vous souhaitez allouer. Dans la plupart des cas, vous pouvez utiliser la valeur par défaut 1. Si votre jeu de données est volumineux, utilisez une taille supérieure.
Fournissez les informations sur les données d'entrée pour le jeu de données d'entraînement.
1. Pour Nom du canal, conservez la valeur par défaut (train) ou saisissez un nom plus descriptif pour l'ensemble de données d'entraînement, par exemple expanded-training-dataset.
2. Pour InputMode, choisissez Fichier. Pour les entraînements incrémentiels, vous devez utiliser le mode d'entrée File (Fichier).
3. Pour le type de distribution de données S3, choisissez FullyReplicated. Ainsi, chaque instance de calcul ML utilise un réplica complet du jeu de données étendu lors de l'entraînement progressif.
4. Si l'ensemble de données étendu n'est pas compressé, définissez le Type de compression sur Aucun. Si l'ensemble de données étendu est compressé à l'aide de Gzip, définissez-le sur Gzip.
5. (Facultatif) Si vous utilisez le mode d'entrée File (Fichier), conservez le Type de contenu vide. Pour le mode d'entrée Pipe (Tube), spécifiez le type MIME approprié. Le type de contenu correspond au type Multipurpose Internet Mail Extensions (MIME) des données.
6. Pour Habillage des enregistrements, si l'ensemble de données est enregistré au format RecordIO, choisissez RecordIO. Si votre ensemble de données n'est pas enregistré en tant que fichier au format RecordIO, choisissez Aucun.
7. Pour Type de données S3, si le jeu de données est stocké en tant que fichier unique, choisissez S3Prefix. Si l'ensemble de données est stocké en tant que plusieurs fichiers dans un dossier, choisissez Manifest.
8. Pour Emplacement S3, fournissez l'URL du chemin d'accès à l'emplacement où vous avez stocké l'ensemble de données étendu.
9. Sélectionnez Exécuté.
Pour utiliser les artefacts de modèle dans une tâche d'entraînement, vous devez ajouter un nouveau canal et fournir les informations nécessaires sur les artefacts du modèle.
1. Pour Configuration des données d'entrée, choisissez Ajouter canal.
2. Pour Nom du canal, saisissez model pour identifier ce canal comme la source des artefacts du modèle.
3. Pour InputMode, choisissez Fichier. Les artefacts de modèle sont stockés sous forme de fichiers.
4. Pour le type de distribution de données S3, choisissez FullyReplicated. Cela indique que chaque instance de calcul ML doit utiliser tous les artefacts du modèle pour l'entraînement.
5. Pour Type de compression, choisissez Aucun, car nous utilisons un modèle pour le canal.
6. Laissez Type de contenu vide. Le type de contenu correspond au type Multipurpose Internet Mail Extensions (MIME) des données. Pour les artefacts de modèle, nous le laissons vide.
7. Définissez Habillage des enregistrements sur Aucun, car les artefacts de modèle ne sont pas stockés au format RecordIO.
8. Pour Type de données S3, si vous utilisez un algorithme intégré ou un algorithme qui stocke le modèle en tant que fichier unique, choisissez S3Prefix. Si vous utilisez un algorithme qui stocke le modèle sous la forme de plusieurs fichiers, choisissez Manifest.
9. Pour Emplacement S3, fournissez l'URL du chemin d'accès à l'emplacement où vous avez stocké les artefacts du modèle. Généralement, le modèle est stocké avec le nom model.tar.gz. Pour trouver l'URL des artefacts du modèle, dans le panneau de navigation, choisissez Déduction, puis choisissez Modèles. Dans la liste des modèles, choisissez un modèle pour afficher sa page de détails. L'URL des artefacts du modèle est répertoriée sous Conteneur principal.
10. Sélectionnez Exécuté.
Pour Configuration des données de sortie, fournissez les informations suivantes :
1. Pour Emplacement S3, tapez le chemin d'accès au compartiment S3 dans lequel vous souhaitez stocker la sortie de données.
2. (Facultatif) Pour Clé de chiffrement, vous pouvez ajouter votre clé de chiffrement AWS Key Management Service (AWS KMS) afin de chiffrer les données de sortie au repos. Fournissez l'ID de clé ou son Amazon Resource Name (ARN). Pour plus d'informations, consultez Clés de chiffrement gérées par KMS.
(Facultatif) Pour Balises, ajoutez une ou plusieurs balises à la tâche d'entraînement. On appelle balise les métadonnées que vous pouvez définir et affecter à des ressources AWS . Dans ce cas, vous pouvez utiliser des balises pour vous aider à gérer vos tâches d'entraînement. Une balise est composée d'une clé et d'une valeur que vous définissez. Par exemple, vous pouvez créer une balise avec Project comme clé et une valeur faisant référence à un projet lié à la tâche d'entraînement, soit par exemple Home value forecasts.
Choisissez Créer un poste de formation. SageMaker crée et gère un poste de formation.

Une fois la tâche d'entraînement terminée, les artefacts du nouveau modèle entraîné sont stockés sous le Chemin de sortie S3 que vous avez fourni dans le champ Configuration des données de sortie. Pour déployer le modèle afin d'obtenir des prédictions, consultez Étape 5 : Déployer le modèle sur Amazon EC2.

Procédure d'entraînement incrémentiel (API)

Cet exemple montre comment utiliser des SageMaker API pour entraîner un modèle à l'aide de l'algorithme de classification SageMaker d'images et du jeu de données d'images Caltech 256, puis comment entraîner un nouveau modèle à l'aide du premier. Il utilise Amazon S3 pour les sources d'entrée et de sortie. Veuillez consulter l'exemple de bloc-notes d'entraînement incrémentiel pour plus de détails sur l'utilisation de l'entraînement incrémentiel.

Note

Dans cet exemple, nous avons utilisé les ensembles de données d'origine dans l'entraînement incrémentiel, mais vous pouvez utiliser d'autres ensembles de données, comme ceux qui contiennent des échantillons nouvellement ajoutés. Chargez les nouveaux ensembles de données dans S3 et apportez des modifications à la variable data_channels utilisée pour entraîner le nouveau modèle.

Obtenez un rôle AWS Identity and Access Management (IAM) qui accorde les autorisations requises et initialise les variables d'environnement :


import sagemaker
from sagemaker import get_execution_role

role = get_execution_role()
print(role)

sess = sagemaker.Session()

bucket=sess.default_bucket()
print(bucket)
prefix = 'ic-incr-training'

Obtenez l'image d'entraînement pour l'algorithme de classification d'images :


from sagemaker.amazon.amazon_estimator import get_image_uri

training_image = get_image_uri(sess.boto_region_name, 'image-classification', repo_version="latest")
#Display the training image
print (training_image)

Téléchargez les jeux de données d'entraînement et de validation, puis téléchargez-les vers Amazon Simple Storage Service (Amazon S3) :


import os
import urllib.request
import boto3

# Define a download function
def download(url):
    filename = url.split("/")[-1]
    if not os.path.exists(filename):
        urllib.request.urlretrieve(url, filename)

# Download the caltech-256 training and validation datasets
download('http://data.mxnet.io/data/caltech-256/caltech-256-60-train.rec')
download('http://data.mxnet.io/data/caltech-256/caltech-256-60-val.rec')

# Create four channels: train, validation, train_lst, and validation_lst
s3train = 's3://{}/{}/train/'.format(bucket, prefix)
s3validation = 's3://{}/{}/validation/'.format(bucket, prefix)

# Upload the first files to the train and validation channels
!aws s3 cp caltech-256-60-train.rec $s3train --quiet
!aws s3 cp caltech-256-60-val.rec $s3validation --quiet

Définissez les hyperparamètres d'entraînement :


# Define hyperparameters for the estimator
hyperparams = { "num_layers": "18",
                "resize": "32",
                "num_training_samples": "50000",
                "num_classes": "10",
                "image_shape": "3,28,28",
                "mini_batch_size": "128",
                "epochs": "3",
                "learning_rate": "0.1",
                "lr_scheduler_step": "2,3",
                "lr_scheduler_factor": "0.1",
                "augmentation_type": "crop_color",
                "optimizer": "sgd",
                "momentum": "0.9",
                "weight_decay": "0.0001",
                "beta_1": "0.9",
                "beta_2": "0.999",
                "gamma": "0.9",
                "eps": "1e-8",
                "top_k": "5",
                "checkpoint_frequency": "1",
                "use_pretrained_model": "0",
                "model_prefix": "" }

Créez un objet évaluateur et entraînez le premier modèle à l'aide des ensembles de données d'entraînement et de validation :


# Fit the base estimator
s3_output_location = 's3://{}/{}/output'.format(bucket, prefix)
ic = sagemaker.estimator.Estimator(training_image,
                                   role,
                                   instance_count=1,
                                   instance_type='ml.p2.xlarge',
                                   volume_size=50,
                                   max_run=360000,
                                   input_mode='File',
                                   output_path=s3_output_location,
                                   sagemaker_session=sess,
                                   hyperparameters=hyperparams)

train_data = sagemaker.inputs.TrainingInput(s3train, distribution='FullyReplicated',
                                        content_type='application/x-recordio', s3_data_type='S3Prefix')
validation_data = sagemaker.inputs.TrainingInput(s3validation, distribution='FullyReplicated',
                                             content_type='application/x-recordio', s3_data_type='S3Prefix')

data_channels = {'train': train_data, 'validation': validation_data}

ic.fit(inputs=data_channels, logs=True)

Pour utiliser le modèle afin d'entraîner de façon incrémentielle un autre modèle, créez un nouvel objet évaluateur et utilisez les artefacts du modèle (ic.model_data, dans cet exemple) pour l'argument d'entrée model_uri :


# Given the base estimator, create a new one for incremental training
incr_ic = sagemaker.estimator.Estimator(training_image,
                                        role,
                                        instance_count=1,
                                        instance_type='ml.p2.xlarge',
                                        volume_size=50,
                                        max_run=360000,
                                        input_mode='File',
                                        output_path=s3_output_location,
                                        sagemaker_session=sess,
                                        hyperparameters=hyperparams,
                                        model_uri=ic.model_data) # This parameter will ingest the previous job's model as a new channel
incr_ic.fit(inputs=data_channels, logs=True)

Une fois la tâche d'entraînement terminée, les artefacts du nouveau modèle entraîné sont stockés sous le chemin de sortie S3 output path que vous avez fourni dans Output_path. Pour déployer le modèle afin d'obtenir des prédictions, consultez Étape 5 : Déployer le modèle sur Amazon EC2.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Se former à l'aide d'un cluster hétérogène

Utilisation de l'entraînement Spot géré