Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utiliser la formation incrémentielle dans Amazon AI 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 plus d’informations sur les tâches d’entraînement, consultez [Entraînez un modèle avec Amazon SageMaker](how-it-works-training.md).
Vous pouvez vous entraîner de manière incrémentielle à l'aide de la console SageMaker AI ou du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
**Important**
Seuls deux algorithmes intégrés prennent actuellement en charge l'entraînement incrémentiel : [Détection d'objets - MXNet](object-detection.md), [Classification des images - MXNet](image-classification.md) et [Algorithme de segmentation sémantique](semantic-segmentation.md).
**Topics**
+ [Procédure d'entraînement incrémentiel (console)](#incremental-training-console)
+ [Procédure d'entraînement incrémentiel (API)](#incremental-training-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](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths).
+ 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 console SageMaker AI, choisissez **Inference**, choisissez **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)**
1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation, choisissez **Training (Entraînement)**, puis **Training jobs (Tâches d’entraînement)**.
1. Choisissez **Créer une tâche d’entraînement**.
1. Indiquez un nom pour la tâche d'entraînement. Le nom doit être unique au sein d'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).
1. Choisissez l'algorithme à utiliser. Pour obtenir des informations sur les algorithmes, consultez [Algorithmes intégrés et modèles préentraînés dans Amazon SageMaker](algos.md).
1. (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.
1. Pour **Nombre d'instances**, utilisez la valeur par défaut 1.
1. (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.
1. 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**.
1. Pour **InputMode**, choisissez **Fichier**. Pour les entraînements incrémentiels, vous devez utiliser le mode d'entrée File (Fichier).
1. 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.
1. 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**.
1. (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.
1. 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**.
1. 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**.
1. Pour **Emplacement S3**, fournissez l'URL du chemin d'accès à l'emplacement où vous avez stocké l'ensemble de données étendu.
1. Sélectionnez **Exécuté**.
1. 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**.
1. Pour **Nom du canal**, saisissez **model** pour identifier ce canal comme la source des artefacts du modèle.
1. Pour **InputMode**, choisissez **Fichier**. Les artefacts de modèle sont stockés sous forme de fichiers.
1. 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.
1. Pour **Type de compression**, choisissez **Aucun**, car nous utilisons un modèle pour le canal.
1. 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.
1. Définissez **Habillage des enregistrements** sur **Aucun**, car les artefacts de modèle ne sont pas stockés au format RecordIO.
1. 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**.
1. 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**.
1. Sélectionnez **Exécuté**.
1. 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.
1. (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](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html).
1. (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**.
1. Choisissez **Créer un poste de formation**. SageMaker L'IA crée et gère des emplois 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 [Déploiement du modèle sur Amazon EC2](ex1-model-deployment.md).
## Procédure d'entraînement incrémentiel (API)
Cet exemple montre comment utiliser l' SageMaker IA pour entraîner un modèle APIs à l'aide de l'algorithme de classification d'images SageMaker AI et du jeu de [données d'images Caltech 256](https://data.caltech.edu/records/nyy15-4j048), 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. Consultez l’[exemple de bloc-notes d’entraînement incrémentiel](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/imageclassification_caltech/Image-classification-incremental-training-highlevel.html) 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 Gestion des identités et des accès AWS (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 [Déploiement du modèle sur Amazon EC2](ex1-model-deployment.md).