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.
# Exécution de tâches d’entraînement sur un cluster hétérogène
À l'aide de la fonctionnalité de cluster hétérogène de SageMaker Training, vous pouvez exécuter une tâche de formation avec plusieurs types d'instances de machine learning pour une meilleure mise à l'échelle et une meilleure utilisation des ressources pour différentes tâches et objectifs de formation ML. Par exemple, si votre tâche d’entraînement sur un cluster avec des instances de processeur graphique souffre d’une faible utilisation du processeur graphique et de problèmes de goulot d’étranglement du processeur en raison de tâches gourmandes en ressources du processeur, l’utilisation d’un cluster hétérogène peut vous aider à décharger ces dernières en ajoutant des groupes d’instances de processeur plus rentables, en résolvant ces problèmes de goulot d’étranglement et en obtenant une meilleure utilisation du processeur graphique.
**Note**
Cette fonctionnalité est disponible dans le SDK SageMaker Python v2.98.0 et versions ultérieures.
**Note**
Cette fonctionnalité est disponible via les classes d'estimateur SageMaker AI [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)et de [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)framework. Les frameworks pris en charge sont la PyTorch v1.10 ou version ultérieure et la TensorFlow version 2.6 ou ultérieure.
Consultez également le blog [Améliorez le rapport prix/performance de votre formation de modèles à l'aide de clusters hétérogènes Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/improve-price-performance-of-your-model-training-using-amazon-sagemaker-heterogeneous-clusters/).
**Topics**
+ [Configurer une tâche de formation avec un cluster hétérogène dans Amazon AI SageMaker](train-heterogeneous-cluster-configure.md)
+ [Exécutez une formation distribuée sur un cluster hétérogène dans Amazon AI SageMaker](train-heterogeneous-cluster-configure-distributed.md)
+ [Modification de votre script d’entraînement pour affecter des groupes d’instances](train-heterogeneous-cluster-modify-training-script.md)
# Configurer une tâche de formation avec un cluster hétérogène dans Amazon AI SageMaker
Cette section fournit des instructions sur la façon d’exécuter une tâche d’entraînement à l’aide d’un cluster hétérogène composé de plusieurs types d’instances.
Notez les points suivants avant de démarrer.
+ Tous les groupes d’instances partagent la même image Docker et le même script d’entraînement. Par conséquent, votre script d’entraînement doit être modifié afin de détecter à quel groupe d’instances il appartient et de l’exécuter en conséquence.
+ La fonctionnalité de cluster hétérogène n'est pas compatible avec le mode local de SageMaker l'IA.
+ Les flux de CloudWatch log Amazon relatifs à une tâche de formation en cluster hétérogène ne sont pas regroupés par groupes d'instances. Vous devez déterminer à partir des journaux quels nœuds appartiennent à quel groupe.
**Topics**
+ [Option 1 : utilisation du SDK SageMaker Python](#train-heterogeneous-cluster-configure-pysdk)
+ [Option 2 : utilisation du bas niveau SageMaker APIs](#train-heterogeneous-cluster-configure-api)
## Option 1 : utilisation du SDK SageMaker Python
Suivez les instructions pour configurer des groupes d'instances pour un cluster hétérogène à l'aide du SDK SageMaker Python.
1. Pour configurer des groupes d’instances d’un cluster hétérogène pour une tâche d’entraînement, utilisez la classe `sagemaker.instance_group.InstanceGroup`. Vous pouvez spécifier un nom personnalisé pour chaque groupe d’instances, le type d’instance et le nombre d’instances pour chaque groupe d’instances. Pour plus d'informations, consultez [sagemaker.instance\$1group. InstanceGroup](https://sagemaker.readthedocs.io/en/stable/api/utility/instance_group.html)dans la *documentation du SDK SageMaker AI Python*.
**Note**
Pour plus d'informations sur les types d'instances disponibles et le nombre maximal de groupes d'instances que vous pouvez configurer dans un cluster hétérogène, consultez la référence de l'[ InstanceGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InstanceGroup.html)API.
L’exemple de code suivant illustre comment configurer deux groupes d’instances composés de deux instances `ml.c5.18xlarge` réservées au processeur nommées `instance_group_1` et une instance `ml.p3dn.24xlarge` du processeur graphique nommée `instance_group_2`, comme illustré dans le schéma suivant.
![\[Un exemple conceptuel de la manière dont les données peuvent être attribuées dans SageMaker Training Job.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/HCTraining.png)
Le schéma précédent montre un exemple conceptuel de la manière dont les processus de pré-entraînement, tels que le prétraitement des données, peuvent être affectés au groupe d’instances CPU et transmettre les données prétraitées au groupe d’instances GPU.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup(
"instance_group_1", "ml.c5.18xlarge", 2
)
instance_group_2 = InstanceGroup(
"instance_group_2", "ml.p3dn.24xlarge", 1
)
```
1. À l'aide des objets du groupe d'instances, configurez les canaux d'entrée d'entraînement et attribuez des groupes d'instances aux canaux via l'`instance_group_names`argument du [sagemaker.inputs. TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)classe. L’argument `instance_group_names` accepte une liste de chaînes de noms de groupes d’instances.
L’exemple suivant montre comment définir deux canaux d’entrée d’entraînement et attribuer les groupes d’instances créés dans l’exemple de l’étape précédente. Vous pouvez également spécifier des chemins de compartiment Amazon S3 vers l’argument `s3_data` pour que les groupes d’instances traitent les données à des fins d’utilisation.
```
from sagemaker.inputs import TrainingInput
training_input_channel_1 = TrainingInput(
s3_data_type='S3Prefix', # Available Options: S3Prefix | ManifestFile | AugmentedManifestFile
s3_data='s3://your-training-data-storage/folder1',
distribution='FullyReplicated', # Available Options: FullyReplicated | ShardedByS3Key
input_mode='File', # Available Options: File | Pipe | FastFile
instance_groups=["instance_group_1"]
)
training_input_channel_2 = TrainingInput(
s3_data_type='S3Prefix',
s3_data='s3://your-training-data-storage/folder2',
distribution='FullyReplicated',
input_mode='File',
instance_groups=["instance_group_2"]
)
```
Pour plus d’informations sur les arguments de `TrainingInput`, consultez les liens suivants.
+ Le [sagemaker.inputs. TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)classe dans la documentation du *SDK SageMaker Python*
+ L'DataSourceAPI [S3](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html) dans la *référence de l'API SageMaker AI*
1. Configurez un estimateur SageMaker AI avec l'`instance_groups`argument comme indiqué dans l'exemple de code suivant. L’argument `instance_groups` accepte une liste de `InstanceGroup` objets.
**Note**
La fonctionnalité de cluster hétérogène est disponible via l' SageMaker IA [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)et les classes d'[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)estimateurs du framework. Les frameworks pris en charge sont la PyTorch v1.10 ou version ultérieure et la TensorFlow version 2.6 ou ultérieure. Pour trouver une liste complète des conteneurs de framework, des versions de framework et des versions Python disponibles, voir [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) dans le GitHub référentiel AWS Deep Learning Container.
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
entry_point='my-training-script.py',
framework_version='x.y.z', # 1.10.0 or later
py_version='pyxy',
job_name='my-training-job-with-heterogeneous-cluster',
instance_groups=[instance_group_1, instance_group_2]
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
entry_point='my-training-script.py',
framework_version='x.y.z', # 2.6.0 or later
py_version='pyxy',
job_name='my-training-job-with-heterogeneous-cluster',
instance_groups=[instance_group_1, instance_group_2]
)
```
------
**Note**
La `instance_type` paire d'`instance_count`arguments and et l'`instance_groups`argument de la classe d'estimateurs SageMaker AI s'excluent mutuellement. Pour une formation en cluster homogène, utilisez la paire d’arguments `instance_type` et `instance_count`. Pour l’entraînement sur les clusters hétérogènes, utilisez `instance_groups`.
**Note**
Pour trouver une liste complète des conteneurs de framework, des versions de framework et des versions Python disponibles, voir [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) dans le GitHub référentiel AWS Deep Learning Container.
1. Configurez la méthode `estimator.fit` avec les canaux d’entrée d’entraînement configurés avec les groupes d’instances et démarrez la tâche d’entraînement.
```
estimator.fit(
inputs={
'training': training_input_channel_1,
'dummy-input-channel': training_input_channel_2
}
)
```
## Option 2 : utilisation du bas niveau SageMaker APIs
Si vous utilisez le AWS Command Line Interface ou AWS SDK pour Python (Boto3) et que vous souhaitez utiliser le bas niveau SageMaker APIs pour soumettre une demande de tâche de formation auprès d'un cluster hétérogène, consultez les références d'API suivantes.
+ [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
+ [ResourceConfig ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ResourceConfig.html)
+ [InstanceGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InstanceGroup.html)
+ [S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)
# Exécutez une formation distribuée sur un cluster hétérogène dans Amazon AI SageMaker
Grâce à l'`distribution`argument de la classe d'estimateur SageMaker AI, vous pouvez attribuer un groupe d'instances spécifique pour exécuter une formation distribuée. Supposons, par exemple, que vous possédez les deux groupes d’instances suivants et que vous souhaitiez exécuter une formation sur multiple processeurs graphiques à l’un d’entre eux.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup("instance_group_1", "ml.c5.18xlarge", 1)
instance_group_2 = InstanceGroup("instance_group_2", "ml.p3dn.24xlarge", 2)
```
Vous pouvez définir la configuration d’entraînement distribuée pour l’un des groupes d’instances. Par exemple, les exemples de code suivants montrent comment attribuer `training_group_2` avec deux instances `ml.p3dn.24xlarge` à la configuration d’entraînement distribuée.
**Note**
Actuellement, un seul groupe d’instances d’un cluster hétérogène peut être spécifié dans la configuration de distribution.
**Avec MPI**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"mpi": {
"enabled": True, "processes_per_host": 8
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"mpi": {
"enabled": True, "processes_per_host": 8
},
"instance_groups": [instance_group_2]
}
)
```
------
**Avec la bibliothèque SageMaker AI data parallel**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"dataparallel": {
"enabled": True
}
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"dataparallel": {
"enabled": True
}
},
"instance_groups": [instance_group_2]
}
)
```
------
**Note**
Lorsque vous utilisez la bibliothèque SageMaker AI data parallel, assurez-vous que le groupe d'instances comprend les [types d'instances pris en charge par la bibliothèque](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-data-parallel-support.html#distributed-data-parallel-supported-instance-types).
Pour plus d'informations sur la bibliothèque SageMaker AI Data Parallel, consultez [SageMaker AI Data Parallel Training](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel.html).
**Avec la bibliothèque parallèle de modèles SageMaker AI**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"modelparallel": {
"enabled":True,
"parameters": {
... # SageMaker AI model parallel parameters
}
}
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"modelparallel": {
"enabled":True,
"parameters": {
... # SageMaker AI model parallel parameters
}
}
},
"instance_groups": [instance_group_2]
}
)
```
------
Pour plus d'informations sur la bibliothèque parallèle de modèles SageMaker AI, consultez [SageMaker AI Model Parallel Training](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel.html).
# Modification de votre script d’entraînement pour affecter des groupes d’instances
Avec la configuration de clusters hétérogène décrite dans les sections précédentes, vous avez préparé l'environnement de SageMaker formation et les instances pour votre tâche de formation. Pour affecter davantage de groupes d’instances à certaines tâches d’entraînement et de traitement des données, l’étape suivante consiste à modifier votre script d’entraînement. Par défaut, la tâche d’entraînement crée simplement des répliques de script d’entraînement pour tous les nœuds, quelle que soit la taille de l’instance, ce qui peut entraîner une perte de performances.
Par exemple, si vous mélangez des instances CPU et GPU dans un cluster hétérogène tout en transmettant un script d'entraînement de réseau neuronal profond à l'`entry_point`argument de l'estimateur SageMaker AI, le `entry_point` script est répliqué sur chaque instance. Cela signifie que, sans affectation de tâches appropriée, les instances de processeur exécutent également l’intégralité du script et lancent la tâche d’entraînement conçue pour l’entraînement distribuée sur les instances de processeur graphique. Par conséquent, vous devez apporter des modifications aux fonctions de traitement spécifiques que vous souhaitez décharger et exécuter sur les instances de processeur. Vous pouvez utiliser les variables d'environnement SageMaker AI pour récupérer les informations du cluster hétérogène et permettre à des processus spécifiques de s'exécuter en conséquence.
Lorsque votre tâche de formation commence, votre script de formation lit les informations relatives à l'environnement de SageMaker formation, notamment la configuration de clusters hétérogènes. La configuration contient des informations telles que les groupes d’instances actuels, les hôtes actuels de chaque groupe et le groupe dans lequel réside l’hôte actuel.
Vous pouvez demander des informations sur les groupes d'instances lors de la phase d'initialisation d'une tâche de formation à l' SageMaker IA de la manière suivante.
**(Recommandé) Lire les informations relatives aux groupes d'instances avec le kit SageMaker de formation**
Utilisez le module Python d'environnement fourni par la [bibliothèque de SageMaker boîtes à outils de formation](https://github.com/aws/sagemaker-training-toolkit). La bibliothèque de boîtes à outils est préinstallée dans les [conteneurs du SageMaker framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) pour TensorFlow et PyTorch, par conséquent, vous n'avez pas besoin d'une étape d'installation supplémentaire lorsque vous utilisez les conteneurs prédéfinis. Il s'agit de la méthode recommandée pour récupérer les variables d'environnement d' SageMaker IA en modifiant moins de code dans votre script d'entraînement.
```
from sagemaker_training import environment
env = environment.Environment()
```
Variables d'environnement liées à la SageMaker formation générale et aux clusters hétérogènes :
+ `env.is_hetero` : renvoie un résultat booléen, qu’un cluster hétérogène soit configuré ou non.
+ `env.current_host` : renvoie l’hôte actuel.
+ `env.current_instance_type` : renvoie le type d’instance de l’hôte actuel.
+ `env.current_instance_group` : renvoie le nom du groupe d’instances actuel.
+ `env.current_instance_group_hosts` : renvoie la liste des hôtes du groupe d’instances actuel.
+ `env.instance_groups` : renvoie une liste des noms de groupes d’instances utilisés pour l’entraînement.
+ `env.instance_groups_dict` : renvoie la configuration de cluster hétérogène complète de la tâche d’entraînement.
+ `env.distribution_instance_groups`— Renvoie la liste des groupes d'instances affectés au `distribution` paramètre de la classe d'estimateur SageMaker AI.
+ `env.distribution_hosts`— Renvoie la liste des hôtes appartenant aux groupes d'instances affectés au `distribution` paramètre de la classe d'estimateur SageMaker AI.
Par exemple, considérez l’exemple suivant d’un cluster hétérogène composé de deux groupes d’instances.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup(
"instance_group_1", "ml.c5.18xlarge", 1)
instance_group_2 = InstanceGroup(
"instance_group_2", "ml.p3dn.24xlarge", 2)
```
La sortie de `env.instance_groups_dict` de l’exemple de cluster hétérogène doit être semblable à ce qui suit.
```
{
"instance_group_1": {
"hosts": [
"algo-2"
],
"instance_group_name": "instance_group_1",
"instance_type": "ml.c5.18xlarge"
},
"instance_group_2": {
"hosts": [
"algo-3",
"algo-1"
],
"instance_group_name": "instance_group_2",
"instance_type": "ml.p3dn.24xlarge"
}
}
```
**(Facultatif) Lecture des informations du groupe d’instances à partir du fichier JSON de configuration de ressources**
Si vous préférez récupérer les variables d’environnement au format JSON, vous pouvez directement utiliser le fichier JSON de configuration des ressources. Le fichier JSON d'une instance d' SageMaker entraînement se trouve `/opt/ml/input/config/resourceconfig.json` par défaut à.
```
file_path = '/opt/ml/input/config/resourceconfig.json'
config = read_file_as_json(file_path)
print(json.dumps(config, indent=4, sort_keys=True))
```