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. # Entraînement d'un modèle à l'aide de Neptune ML Après avoir traité les données que vous avez exportées de Neptune pour l'entraînement de modèle, vous pouvez démarrer une tâche d'entraînement de modèle à l'aide d'une commande `curl` (ou `awscurl`) comme la suivante : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" }' ``` Les détails de l'utilisation de cette commande sont expliqués dans [Commande modeltraining](machine-learning-api-modeltraining.md), avec d'autres informations sur la façon d'obtenir le statut d'une tâche en cours d'exécution, d'arrêter une tâche en cours d'exécution et de répertorier toutes les tâches en cours d'exécution. Vous pouvez également fournir un identifiant `previousModelTrainingJobId` pour utiliser les informations issues d'une tâche d'entraînement de modèle Neptune ML terminée, afin d'accélérer la recherche d'hyperparamètres dans une nouvelle tâche d'entraînement. Cela est utile lors du [réentraînement de modèle sur de nouvelles données de graphe](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining), ainsi que lors de l'[entraînement incrémentiel sur les mêmes données de graphe](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental). Utilisez une commande comme celle-ci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "previousModelTrainingJobId" : "(the model-training job-id of a completed job)" }' ``` Vous pouvez entraîner votre propre implémentation de modèle sur l'infrastructure d'entraînement Neptune ML en fournissant un objet `customModelTrainingParameters` tel que celui-ci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "modelName": "custom", "customModelTrainingParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "trainingEntryPointScript": "(your training script entry-point name in the Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` Consultez [Commande modeltraining](machine-learning-api-modeltraining.md) pour plus d'informations, notamment sur la façon d'obtenir le statut d'une tâche en cours d'exécution, la façon d'arrêter une tâche en cours d'exécution et la façon de répertorier toutes les tâches en cours d'exécution. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour en savoir plus sur la façon d'implémenter et d'utiliser un modèle personnalisé. **Topics** + [ # Modèles et entraînement de modèle dans Amazon Neptune ML ](machine-learning-models-and-training.md) + [ # Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML ](machine-learning-customizing-hyperparams.md) + [ # Bonnes pratiques d'entraînement de modèle ](machine-learning-improve-model-performance.md) # Modèles et entraînement de modèle dans Amazon Neptune ML Neptune ML utilise les réseaux de neurones en graphes (GNN) pour créer des modèles pour les différentes tâches de machine learning. Il a été démontré que les réseaux neuronaux graphiques obtiennent des state-of-the-art résultats pour les tâches d'apprentissage automatique des graphes et sont excellents pour extraire des modèles informatifs à partir de données structurées par des graphes. ## Réseaux neuronaux graphiques (GNNs) dans Neptune ML Les réseaux neuronaux à graphes (GNNs) appartiennent à une famille de réseaux neuronaux qui calculent les représentations des nœuds en tenant compte de la structure et des caractéristiques des nœuds voisins. GNNs complètent d'autres méthodes traditionnelles d'apprentissage automatique et de réseaux neuronaux qui ne sont pas bien adaptées aux données graphiques. GNNs sont utilisés pour résoudre des tâches d'apprentissage automatique telles que la classification et la régression des nœuds (prédiction des propriétés des nœuds), la classification et la régression des arêtes (prédiction des propriétés des arêtes) ou la prédiction des liens (prédiction si deux nœuds du graphe doivent être connectés ou non). En général, l'utilisation d'un réseau GNN pour une tâche de machine learning comporte deux phases : + Une phase d'encodage, au cours de laquelle le réseau GNN calcule un vecteur à d dimensions pour chaque nœud du graphe. Ces vecteurs sont également appelés *représentations* ou *intégrations*. + Une phase de décodage, qui effectue des prédictions basées sur les représentations encodées. Pour la classification et la régression de nœud, les représentations des nœuds sont utilisées directement pour les tâches de classification et de régression. Pour la classification et la régression d'arête, les représentations de nœud des nœuds incidents sur une arête sont utilisées comme entrée pour la classification ou la régression. Pour la prédiction de lien, un score de probabilité d'arête est calculé à l'aide d'une paire de représentations de nœud et d'une représentation de type d'arête. La [Deep Graph Library (DGL)](https://www.dgl.ai/) facilite la définition et la formation efficaces GNNs de ces tâches. Différents modèles GNN sont unifiés dans le cadre de la formulation de la transmission de messages. Dans cette vue, la représentation d'un nœud dans un graphe est calculée à l'aide des représentations des voisins du nœud (les messages), ainsi que de la représentation initiale du nœud. Dans NeptuneML, la représentation initiale d'un nœud est dérivée des fonctionnalités extraites de ses propriétés de nœud, ou elle peut être apprise et dépend de l'identité du nœud. Neptune ML offre également la possibilité de concaténer les fonctionnalités de nœud et les représentations de nœud pouvant être apprises pour servir de représentation de nœud d'origine. Pour les diverses tâches dans Neptune ML impliquant des graphes dotés de propriétés de nœud, nous utilisons le [réseau convolutif graphique relationnel](https://arxiv.org/abs/1703.06103) (R-GCN) pour effectuer la phase d'encodage. R-GCN est une architecture GNN parfaitement adaptée aux graphes comportant plusieurs types de nœud et d'arête (ils sont appelés graphes hétérogènes). Le réseau R-GCN est constitué d'un nombre fixe de couches empilées les unes après les autres. Chaque couche du R-GCN utilise ses paramètres de modèle pouvant être appris pour agréger les informations provenant du voisinage à un saut, immédiat d'un nœud. Comme les couches suivantes utilisent les représentations en sortie de la couche précédente comme entrée, le rayon du voisinage de graphe qui influence l'intégration finale d'un nœud dépend du nombre de couches (`num-layer`) du réseau R-GCN. Par exemple, cela signifie qu'un réseau à deux couches utilise les informations provenant de nœuds situés à deux sauts de distance. Pour en savoir plus GNNs, consultez [A Comprehensive Survey on Graph Neural Networks](https://arxiv.org/abs/1901.00596). Pour plus d'informations sur la bibliothèqe Deep Graph Library (DGL), visitez la [page Web](https://www.dgl.ai/) de la DGL. Pour un didacticiel pratique sur l'utilisation de DGL avec GNNs, voir [Apprendre les réseaux neuronaux à graphes avec Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library). ## Réseaux de neurones en graphes d'entraînement Dans le machine learning, le processus qui consiste à amener un modèle à apprendre à effectuer de bonnes prédictions pour une tâche s'appelle « entraînement de modèle ». Il est généralement réalisé en spécifiant un objectif particulier à optimiser, ainsi qu'un algorithme à utiliser pour effectuer cette optimisation. Ce processus est utilisé pour entraîner un réseau GNN à apprendre de bonnes représentations également pour la tâche en aval. Nous créons une fonction objectif pour cette tâche qui est minimisée lors de l'entraînement du modèle. Par exemple, pour la classification des nœuds, nous utilisons [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)comme objectif, ce qui pénalise les erreurs de classification, et pour la régression des nœuds, nous minimisons. [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html) L'objectif est généralement une fonction de perte qui prend les prédictions du modèle pour un point de données particulier et les compare à la valeur réelle pour ce point de données. Il renvoie la valeur de perte, qui indique à quel point les prédictions du modèle sont éloignées. L'objectif du processus d'entraînement est de minimiser les pertes et de s'assurer que les prédictions du modèle sont proches de la réalité. L'algorithme d'optimisation utilisé en deep learning pour le processus d'entraînement est généralement une variante de la descente de gradient. Dans Neptune ML, nous utilisons [Adam](https://arxiv.org/pdf/1412.6980.pdf), un algorithme d'optimisation des fonctions objectives stochastiques basé sur un gradient de premier ordre, sur la base d'estimations adaptatives de moments d'ordre inférieur. Alors que le processus d'entraînement de modèle essaie de s'assurer que les paramètres de modèle appris sont proches des minima de la fonction objectif, les performances globales d'un modèle dépendent également des *hyperparamètres* du modèle, qui sont des paramètres de modèle qui ne sont pas appris par l'algorithme d'entraînement. Par exemple, la dimensionnalité de la représentation de nœud appris, `num-hidden`, est un hyperparamètre qui affecte les performances du modèle. Par conséquent, il est courant en machine learning d'effectuer une optimisation des hyperparamètres (HPO) pour choisir les hyperparamètres appropriés. Neptune ML utilise une tâche de réglage des hyperparamètres basée sur l' SageMaker IA pour lancer plusieurs instances d'apprentissage de modèles avec différentes configurations d'hyperparamètres afin de trouver le meilleur modèle pour une gamme de paramètres d'hyperparamètres. Consultez [Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML](machine-learning-customizing-hyperparams.md). ## Modèles d'intégration de graphe de connaissances dans Neptune ML Les graphes de connaissances (KGs) sont des graphes qui encodent des informations sur les différentes entités (nœuds) et leurs relations (arêtes). Dans Neptune ML, les modèles d'intégration de graphe de connaissances sont appliqués par défaut pour effectuer une prédiction de lien lorsque le graphe ne contient pas de propriétés de nœud, mais uniquement des relations avec d'autres nœuds. Des modèles R-GCN avec intégrations pouvant être apprises peuvent également être utilisés pour ces graphes en spécifiant le type de modèle `"rgcn"`, mais les modèles d'intégration de graphe de connaissances sont plus simples et sont conçus pour être efficaces pour l'apprentissage de représentations pour des graphes de connaissances à grande échelle. Les modèles d'intégration de graphe de connaissances sont utilisés dans une tâche de prédiction de lien pour prédire les nœuds ou les relations qui complètent un triple `(h, r, t)` où `h` est le nœud source, `r` le type de relation et `t` le nœud de destination. Les modèles d'intégration de graphe de connaissances implémentés dans Neptune ML sont `distmult`, `transE` et `rotatE`. Pour en savoir plus sur les modèles d'intégration de graphe de connaissances, consultez [DGL-KE](https://github.com/awslabs/dgl-ke). ## Entraînement de modèles personnalisés dans Neptune ML Neptune ML vous permet de définir et d'implémenter vos propres modèles personnalisés, pour des scénarios particuliers. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour en savoir plus sur la manière d'implémenter un modèle personnalisé et sur la manière d'utiliser l'infrastructure Neptune ML pour l'entraîner. # Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML Lorsque vous démarrez une tâche d'entraînement de modèle Neptune ML, Neptune ML utilise automatiquement les informations déduites de la tâche de [traitement de données](machine-learning-on-graphs-processing.md) précédente. Il utilise les informations pour générer des plages de configuration d'hyperparamètres qui sont utilisées pour créer une tâche de [réglage d'hyperparamètres basée sur l'SageMaker IA afin d'entraîner plusieurs modèles pour votre tâche](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html). Ainsi, il n'est pas nécessaire de spécifier une longue liste de valeurs d'hyperparamètres à utiliser pour entraîner les modèles. Au lieu de cela, les valeurs par défaut et les plages d'hyperparamètres de modèle sont sélectionnées en fonction du type de tâche, du type de graphe et des paramètres de la tâche de réglage. Toutefois, vous pouvez également remplacer la configuration des hyperparamètres par défaut et fournir des hyperparamètres personnalisés en modifiant un fichier de configuration JSON généré par la tâche de traitement des données. À l'aide de l'[API modelTraining](machine-learning-api-modeltraining.md) de Neptune ML, vous pouvez contrôler plusieurs paramètres de tâche de réglage d'hyperparamètres de haut niveau, tels que `maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs` et `trainingInstanceType`. Pour un contrôle plus précis des hyperparamètres du modèle, vous pouvez personnaliser le fichier `model-HPO-configuration.json` généré par la tâche de traitement de données. Le fichier est enregistré à l'emplacement Amazon S3 que vous avez spécifié pour la sortie de la tâche de traitement. Vous pouvez télécharger le fichier, le modifier pour remplacer les configurations d'hyperparamètres par défaut, puis le charger à nouveau dans le même emplacement Amazon S3. Ne modifiez pas le nom du fichier et veillez à suivre ces instructions lorsque vous le modifiez. Pour télécharger le fichier à partir d'Amazon S3 : ``` aws s3 cp \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \ ./ ``` Lorsque vous avez terminé la modification, rechargez le fichier là où il se trouvait : ``` aws s3 cp \ model-HPO-configuration.json \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json ``` ## Structure du fichier `model-HPO-configuration.json` Le fichier `model-HPO-configuration.json` spécifie le modèle à entraîner, l'élément `task_type` de machine learning et les hyperparamètres qui doivent être modulés ou fixés pour les diverses exécutions d'entraînement de modèle. Les hyperparamètres sont classés comme appartenant à différents niveaux qui indiquent la priorité accordée aux hyperparamètres lorsque la tâche de réglage des hyperparamètres est invoquée : + Les hyperparamètres de niveau 1 ont la priorité la plus élevée. Si vous définissez `maxHPONumberOfTrainingJobs` sur une valeur inférieure à 10, seuls les hyperparamètres de niveau 1 sont réglés et les autres adoptent leurs valeurs par défaut. + Les hyperparamètres de niveau 2 ont une priorité inférieure. Ainsi, si vous avez plus de 10 mais moins de 50 tâches d'entraînement au total pour une tâche de réglage, les hyperparamètres des niveaux 1 et 2 sont réglés. + Les hyperparamètres de niveau 3 sont réglés avec les niveaux 1 et 2 uniquement si vous avez un total de plus de 50 tâches d'entraînement. + Enfin, les hyperparamètres fixés ne sont pas du tout réglés et adoptent toujours leurs valeurs par défaut. ### Exemple de fichier `model-HPO-configuration.json` Voici un exemple de fichier `model-HPO-configuration.json` : ``` { "models": [ { "model": "rgcn", "task_type": "node_class", "eval_metric": { "metric": "acc" }, "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, "1-tier-param": [ { "param": "num-hidden", "range": [16, 128], "type": "int", "inc_strategy": "power2" }, { "param": "num-epochs", "range": [3,30], "inc_strategy": "linear", "inc_val": 1, "type": "int", "node_strategy": "perM" }, { "param": "lr", "range": [0.001,0.01], "type": "float", "inc_strategy": "log" } ], "2-tier-param": [ { "param": "dropout", "range": [0.0,0.5], "inc_strategy": "linear", "type": "float", "default": 0.3 }, { "param": "layer-norm", "type": "bool", "default": true } ], "3-tier-param": [ { "param": "batch-size", "range": [128, 4096], "inc_strategy": "power2", "type": "int", "default": 1024 }, { "param": "fanout", "type": "int", "options": [[10, 30],[15, 30], [15, 30]], "default": [10, 15, 15] }, { "param": "num-layer", "range": [1, 3], "inc_strategy": "linear", "inc_val": 1, "type": "int", "default": 2 }, { "param": "num-bases", "range": [0, 8], "inc_strategy": "linear", "inc_val": 2, "type": "int", "default": 0 } ], "fixed-param": [ { "param": "concat-node-embed", "type": "bool", "default": true }, { "param": "use-self-loop", "type": "bool", "default": true }, { "param": "low-mem", "type": "bool", "default": true }, { "param": "l2norm", "type": "float", "default": 0 } ] } ] } ``` ### Éléments d'un fichier `model-HPO-configuration.json` Le fichier contient un objet JSON avec un seul tableau de niveau supérieur nommé `models` contenant un seul objet de configuration de modèle. Lorsque vous personnalisez le fichier, assurez-vous que le tableau `models` ne contient qu'un seul objet de configuration de modèle. Si votre fichier contient plusieurs objets de configuration de modèle, la tâche de réglage échouera avec un avertissement. L'objet de configuration de modèle contient les éléments de haut niveau suivants : + **`model`** : (*string*) type de modèle à entraîner (**ne pas modifier**). Les valeurs valides sont : + `"rgcn"` : il s'agit de la valeur par défaut pour les tâches de classification et de régression de nœud, ainsi que pour les tâches de prédiction de lien hétérogènes. + `"transe"` : il s'agit de la valeur par défaut pour les tâches de prédiction de lien KGE. + `"distmult"` : il s'agit d'un type de modèle alternatif pour les tâches de prédiction de lien KGE. + `"rotate"` : il s'agit d'un type de modèle alternatif pour les tâches de prédiction de lien KGE. En règle générale, ne modifiez pas directement la valeur `model`, car les différents types de modèles ont souvent des hyperparamètres applicables sensiblement différents, ce qui peut entraîner une erreur d'analyse après le début de la tâche d'entraînement. Pour modifier le type de modèle, utilisez le paramètre `modelName` de l'[API modelTraining](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) au lieu de le modifier dans le fichier `model-HPO-configuration.json`. Une manière de modifier le type de modèle et d'apporter des modifications fines aux hyperparamètres consiste à copier le modèle de configuration de modèle par défaut pour le modèle que vous souhaitez utiliser et à le coller dans le fichier `model-HPO-configuration.json`. Il existe un dossier nommé `hpo-configuration-templates` au même emplacement Amazon S3 que le fichier `model-HPO-configuration.json` si le type de tâche déduit prend en charge plusieurs modèles. Ce dossier contient toutes les configurations d'hyperparamètres par défaut pour les autres modèles applicables à la tâche. Par exemple, si vous souhaitez modifier les configurations de modèle et d'hyperparamètres d'une tâche de prédiction de lien `KGE` en passant du modèle `transe` par défaut à un modèle `distmult`, il vous suffit de coller le contenu du fichier `hpo-configuration-templates/distmult.json` dans le fichier `model-HPO-configuration.json`, puis d'apporter les modifications nécessaires aux hyperparamètres. **Note** Si vous définissez le paramètre `modelName` dans l'API `modelTraining` et modifiez également la spécification des hyperparamètres et de `model` dans le fichier `model-HPO-configuration.json`, et que ceux-ci sont différents, la valeur `model` du fichier `model-HPO-configuration.json` est prioritaire et la valeur `modelName` est ignorée. + **`task_type`** : (*string*) type de tâche de machine learning déduit par la tâche de traitement des données ou transmis directement à cette tâche (**ne pas modifier**). Les valeurs valides sont : + `"node_class"` + `"node_regression"` + `"link_prediction"` La tâche de traitement des données déduit le type de tâche en examinant les propriétés du jeu de données exporté et du fichier généré de configuration de tâche d'entraînement. Cette valeur ne doit pas être modifiée. Si vous souhaitez entraîner une autre tâche, vous devez [exécuter une nouvelle tâche de traitement de données](machine-learning-on-graphs-processing.md). Si la valeur `task_type` n'est pas celle que vous attendiez, vous devez vérifier les entrées de votre tâche de traitement de données pour vous assurer qu'elles sont correctes. Cela inclut les paramètres de l'API `modelTraining`, ainsi que ceux du fichier de configuration de tâche d'entraînement généré par le processus d'exportation de données. + **`eval_metric`** : (*string*) la métrique d'évaluation doit être utilisée pour évaluer les performances de modèle et pour sélectionner le modèle le plus performant lors des exécutions HPO. Les valeurs valides sont : + `"acc"` : précision de classification standard. Il s'agit de la valeur par défaut pour les tâches de classification à étiquette unique, sauf si des étiquettes déséquilibrées sont détectées lors du traitement des données, auquel cas la valeur par défaut est `"F1"`. + `"acc_topk"` : nombre de fois où l'étiquette correcte figure parmi les meilleures prédictions **`k`**. Vous pouvez également définir la valeur **`k`** en transmettant `topk` comme clé supplémentaire. + `"F1"` : le [score F1](https://en.wikipedia.org/wiki/F-score). + `"mse"` : [métrique d'erreur quadratique moyenne](https://en.wikipedia.org/wiki/Mean_squared_error) pour les tâches de régression. + `"mrr"` : [métrique de rang réciproque moyen](https://en.wikipedia.org/wiki/Mean_reciprocal_rank). + `"precision"` : la précision du modèle, calculée comme le rapport entre les vrais positifs et les positifs prédits : `= true-positives / (true-positives + false-positives)`. + `"recall"` : le rappel du modèle, calculé comme le rapport entre les vrais positifs et les positifs réels : `= true-positives / (true-positives + false-negatives)`. + `"roc_auc"` : l'aire située sous la [courbe ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Il s'agit de la valeur par défaut pour la classification à plusieurs étiquettes. Par exemple, pour remplacer la métrique par `F1`, modifiez la valeur `eval_metric` comme suit : ``` " eval_metric": { "metric": "F1", }, ``` Ou, pour remplacer la métrique par un score de précision `topk`, vous devez modifier `eval_metric` comme suit : ``` "eval_metric": { "metric": "acc_topk", "topk": 2 }, ``` + **`eval_frequency`** : (*objet*) spécifie à quelle fréquence il convient de vérifier les performances du modèle sur le jeu de validation pendant l'entraînement. Sur la base des performances de validation, il est alors possible d'initier un arrêt anticipé et d'enregistrer le meilleur modèle. L'objet `eval_frequency` contient deux éléments, à savoir `"type"` et `"value"`. Par exemple : ``` "eval_frequency": { "type": "evaluate_every_pct", "value": 0.1 }, ``` Les valeurs `type` valides sont : + **`evaluate_every_pct`** : spécifie le pourcentage d'entraînement à suivre pour chaque évaluation. Pour `evaluate_every_pct`, le champ `"value"` contient un nombre à virgule flottante compris entre zéro et un, qui exprime ce pourcentage. + **`evaluate_every_batch`** : spécifie le nombre de lots d'entraînement à traiter pour chaque évaluation. Pour `evaluate_every_batch`, le champ `"value"` contient un entier qui exprime ce nombre de lots. + **`evaluate_every_epoch`** : spécifie le nombre d'époques par évaluation, une nouvelle époque commençant à minuit. Pour `evaluate_every_epoch`, le champ `"value"` contient un entier qui exprime ce nombre d'époques. Le paramètre par défaut pour `eval_frequency` est : ``` "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, ``` + **`1-tier-param`** : (*obligatoire*) tableau d'hyperparamètres de niveau 1. Si vous ne souhaitez régler aucun hyperparamètre, vous pouvez définir cet élément sur un tableau vide. Cela n'affecte pas le nombre total de tâches de formation lancées par la tâche de réglage des hyperparamètres de l' SageMaker IA. Cela signifie simplement que toutes les tâches d'entraînement, s'il y en a plus de 1 mais moins de 10, seront exécutées avec le même ensemble d'hyperparamètres. D'un autre côté, si vous souhaitez traiter tous vos hyperparamètres réglables avec une importance égale, vous pouvez placer tous les hyperparamètres dans ce tableau. + **`2-tier-param`** : (*obligatoire*) tableau d'hyperparamètres de niveau 2. Ces paramètres sont réglés uniquement si `maxHPONumberOfTrainingJobs` a une valeur supérieure à 10. Dans le cas contraire, ils sont fixés aux valeurs par défaut. Si vous avez un budget d'entraînement de 10 tâches d'entraînement au maximum ou ne souhaitez pas d'hyperparamètres de niveau 2 pour une raison quelconque, mais que vous souhaitez régler tous les hyperparamètres réglables, vous pouvez définir cet élément sur un tableau vide. + **`3-tier-param`** : (*obligatoire*) tableau d'hyperparamètres de niveau 3. Ces paramètres sont réglés uniquement si `maxHPONumberOfTrainingJobs` a une valeur supérieure à 50. Dans le cas contraire, ils sont fixés aux valeurs par défaut. Si vous ne souhaitez pas d'hyperparamètres de niveau 3, vous pouvez définir cet élément sur un tableau vide. + **`fixed-param`** : (*obligatoire*) un tableau d'hyperparamètres fixes qui ne prennent que leurs valeurs par défaut et ne varient pas dans les différentes tâches d'entraînement. Si vous souhaitez moduler tous les hyperparamètres, vous pouvez définir cet élément sur un tableau vide et définir une valeur de `maxHPONumberOfTrainingJobs` suffisamment grande pour faire varier tous les niveaux ou définir tous les hyperparamètres au niveau 1. L'objet JSON qui représente chaque hyperparamètre dans `1-tier-param`, `2-tier-param`, `3-tier-param` et `fixed-param` contient les éléments suivants : + **`param`** : (*string*) nom de l'hyperparamètre (**ne pas modifier**). Consultez la [liste des noms d'hyperparamètre valides dans Neptune ML](#machine-learning-hyperparams-list). + **`type`** : (*string*) type d'hyperparamètre (**ne pas modifier**). Les types valides sont : `bool`, `int` et `float`. + **`default`** : (*string*) valeur par défaut de l'hyperparamètre. Vous pouvez définir une nouvelle valeur par défaut. Les hyperparamètres réglables peuvent également contenir les éléments suivants : + **`range`** : (*array*) plage d'un hyperparamètre réglable continu. Il doit s'agir d'un tableau à deux valeurs, à savoir le minimum et le maximum de la plage (`[min, max]`). + **`options`** : (*array*) options pour un hyperparamètre réglable catégoriel. Ce tableau doit contenir toutes les options à prendre en compte : ``` "options" : [value1, value2, ... valuen] ``` + **`inc_strategy`** : (*string*) type de modification incrémentielle pour les plages d'hyperparamètres réglables continus (**ne pas modifier**). Les valeurs valides sont `log`, `linear` et `power2`. Cela s'applique uniquement lorsque la clé de plage est définie. Si vous modifiez cet élément, vous risquez de ne pas utiliser toute la plage de votre hyperparamètre pour le réglage. + **`inc_val`** : (*float*) différence entre les incréments successifs pour les hyperparamètres réglables continus (**ne pas modifier**). Cela s'applique uniquement lorsque la clé de plage est définie. Si vous modifiez cet élément, vous risquez de ne pas utiliser toute la plage de votre hyperparamètre pour le réglage. + **`node_strategy`** : (*string*) indique que la plage effective de cet hyperparamètre doit changer en fonction du nombre de nœuds du graphe (**ne pas modifier**). Les valeurs valides sont `"perM"` (par million), `"per10M"` (pour 10 millions) et `"per100M"` (pour 100 millions). Plutôt que de modifier cette valeur, modifiez `range`. + **`edge_strategy`** : (*string*) indique que la plage effective de cet hyperparamètre doit changer en fonction du nombre d'arêtes dans le graphe (**ne pas modifier**). Les valeurs valides sont `"perM"` (par million), `"per10M"` (pour 10 millions) et `"per100M"` (pour 100 millions). Plutôt que de modifier cette valeur, modifiez `range`. ### Liste de tous les hyperparamètres dans Neptune ML La liste suivante contient tous les hyperparamètres qui peuvent être définis n'importe où dans Neptune ML, pour tout type de modèle et toute tâche. Comme ils ne sont pas tous applicables à tout type de modèle, il est important de définir dans le fichier `model-HPO-configuration.json` seulement les hyperparamètres qui apparaissent dans le modèle relatif au modèle que vous utilisez. + **`batch-size`** : taille du lot de nœuds cibles utilisé en un seul transfert. *Type* : `int`. La définition d'une valeur beaucoup plus élevée peut entraîner des problèmes de mémoire lors de l'entraînement sur des instances GPU. + **`concat-node-embed`** : indique s'il faut obtenir la représentation initiale d'un nœud en concaténant ses fonctionnalités traitées avec des intégrations initiales de nœuds pouvant être apprises afin d'augmenter l'expressivité du modèle. *Type* : `bool`. + **`dropout`** : probabilité d'abandon appliquée aux couches d'abandon. *Type* : `float`. + **`edge-num-hidden`** : taille de la couche masquée ou nombre d'unités pour le module de fonctionnalités d'arête. Utilisé uniquement quand `use-edge-features` a pour valeur `True`. *Type* : float. + **`enable-early-stop`** : permet d'utiliser ou non la fonctionnalité d'arrêt anticipé. *Type* : `bool`. *Par défaut* : `true`. Utilisez ce paramètre booléen pour désactiver la fonctionnalité d'arrêt anticipé. + **`fanout`** : nombre de voisins à échantillonner pour un nœud cible lors de l'échantillonnage des voisins. *Type* : `int`. Cette valeur est étroitement liée à `num-layers` et devrait toujours figurer au même niveau d'hyperparamètres. Cela est dû au fait que vous pouvez spécifier une diffusion en éventail pour chaque couche GNN potentielle. Étant donné que cet hyperparamètre peut entraîner des variations importantes des performances de modèle, il devrait être fixé ou défini en tant qu'hyperparamètre de niveau 2 ou 3. Lui affecter une valeur élevée peut entraîner des problèmes de mémoire lors de l'entraînement sur des instances GPU. + **`gamma`** : valeur de marge dans la fonction de score. *Type* : `float`. Elle s'applique uniquement aux modèles de prédiction de lien `KGE`. + **`l2norm`** : valeur de dégradation de poids utilisée dans l'optimiseur, qui impose une pénalité de normalisation L2 aux poids. *Type* : `bool`. + **`layer-norm`** : indique s'il convient d'utiliser la normalisation des couches pour les modèles `rgcn`. *Type* : `bool`. + **`low-mem`** : indique s'il convient d'utiliser une implémentation à faible mémoire de la fonction de transmission des messages relationnels au détriment de la vitesse. *Type* : `bool`. + **`lr`** : taux d'apprentissage. *Type* : `float`. Il doit être défini en tant qu'hyperparamètre de niveau 1. + **`neg-share`** : dans le cadre de la prédiction de lien, indique si les arêtes échantillonnées positives peuvent partager des échantillons d'arête négatifs. *Type* : `bool`. + **`num-bases`** : nombre de bases pour la décomposition des bases dans un modèle `rgcn`. L'utilisation d'une valeur `num-bases` inférieure au nombre de types d'arête dans le graphe agit comme un régularisateur pour le modèle `rgcn`. *Type* : `int`. + **`num-epochs`** : nombre d'époques d'entraînement à exécuter. *Type* : `int`. Une époque est un parcours d'entraînement complet à travers le graphe. + **`num-hidden`** : taille de la couche masquée ou nombre d'unités. *Type* : `int`. Cela définit également la taille d'intégration initiale pour les nœuds sans fonctionnalités. La définir sur une valeur beaucoup plus élevée sans la réduire `batch-size` peut entraîner des out-of-memory problèmes d'entraînement sur une instance GPU. + **`num-layer`** : nombre de couches GNN dans le modèle. *Type* : `int`. Cette valeur est étroitement liée au paramètre de diffusion en éventail et devrait être définie après la diffusion en éventail au même niveau d'hyperparamètres. Étant donné qu'elle peut entraîner des variations importantes des performances de modèle, elle devrait être fixée ou définie en tant qu'hyperparamètre de niveau 2 ou 3. + **`num-negs`** : dans le cadre de la prédiction de lien, nombre d'échantillons négatifs par échantillon positif. *Type* : `int`. + **`per-feat-name-embed`** : indique s'il faut intégrer chaque fonctionnalité en la transformant indépendamment avant de combiner les fonctionnalités. *Type* : `bool`. Lorsque cette valeur est définie sur `true`, chaque fonctionnalité par nœud est transformée indépendamment en une taille de dimension fixe avant que toutes les fonctionnalités transformées pour le nœud soient concaténées puis transformées dans la dimension `num_hidden`. Lorsque la valeur `false` est définie, les fonctionnalités sont concaténées sans aucune transformation spécifique aux fonctionnalités. + **`regularization-coef`** : dans le cadre de la prédiction de lien, coefficient de perte de régularisation. *Type* : `float`. + **`rel-part`** : indique s'il convient d'utiliser une partition de relation pour la prédiction de lien `KGE`. *Type* : `bool`. + **`sparse-lr`** : taux d'apprentissage pour les intégrations de nœuds pouvant être appris. *Type* : `float`. Les intégrations initiales de nœuds pouvant être appris sont utilisées pour les nœuds sans fonctionnalités ou quand `concat-node-embed` est défini. Les paramètres de la couche d'intégration fragmentée de nœuds pouvant être appris sont entraînés à l'aide d'un optimiseur distinct qui peut avoir un taux d'apprentissage distinct. + **`use-class-weight`** : indique s'il convient d'appliquer des pondérations de classe pour les tâches de classification déséquilibrée. Si la valeur `true` est définie, les nombres d'étiquettes sont utilisés pour définir un poids pour chaque étiquette de classe. *Type* : `bool`. + **`use-edge-features`** : indique s'il convient d'utiliser les fonctionnalités d'arête lors de la transmission de messages. Si la valeur `true` est définie, un module de fonctionnalités d'arête personnalisé est ajouté à la couche RGCN pour les types d'arête comportant des fonctionnalités. *Type* : `bool`. + **`use-self-loop`** : indique s'il convient d'inclure les boucles automatiques dans l'entraînement d'un modèle `rgcn`. *Type* : `bool`. + **`window-for-early-stop`** : contrôle le nombre des derniers scores de validation à la moyenne pour décider ou non d'un arrêt anticipé. La valeur par défaut est 3. type=int. Consultez également [Arrêt anticipé du processus d'entraînement de modèle dans Neptune ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Type* : `int`. *Par défaut* : `3`. Consultez . ## Personnalisation des hyperparamètres dans Neptune ML Lorsque vous modifiez le fichier `model-HPO-configuration.json`, les types de modifications les plus courants sont les suivants : + Modifiez les valeurs and/or maximales minimales des `range` hyperparamètres. + Affectez une valeur fixe à un hyperparamètre en le déplaçant vers la section `fixed-param` et en définissant sa valeur par défaut sur la valeur fixe que vous souhaitez qu'il prenne. + Modifiez la priorité d'un hyperparamètre en le plaçant dans un niveau spécifique, en modifiant sa plage et en vous assurant que sa valeur par défaut est définie de manière appropriée. # Bonnes pratiques d'entraînement de modèle Il y a des choses que vous pouvez faire pour améliorer les performances des modèles Neptune ML. ## Choisir la propriété de nœud appropriée Toutes les propriétés de votre graphe ne sont pas significatives ou pertinentes pour vos tâches de machine learning. Toute propriété non pertinente doit être exclue lors de l'exportation des données. Voici quelques bonnes pratiques : + Faites appel à des experts du domaine pour vous aider à évaluer l'importance des fonctionnalités et la faisabilité de leur utilisation pour les prédictions. + Supprimez les fonctionnalités que vous considérez redondantes ou non pertinentes afin de réduire le bruit dans les données et les corrélations superflues. + Effectuez une itération au fur et à mesure que vous créez votre modèle. Ajustez les fonctionnalités, les combinaisons de fonctionnalités et les objectifs de réglage au fur et à mesure. La rubrique [Fonctionnalisation](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html) du Guide du développeur d'Amazon Machine Learning fournit des instructions supplémentaires relatives à la fonctionnalisation, qui sont pertinentes pour Neptune ML. ## Gérer les points de données aberrants Une aberration est un point de données très différent des autres données. Les données aberrantes peuvent gâcher ou induire en erreur le processus d'entraînement, ce qui peut conduire à un allongement du temps d'entraînement ou à des modèles moins précis. À moins qu'elles soient vraiment importantes, vous devez éliminer les aberrations avant d'exporter les données. ## Supprimer les nœuds et les arêtes dupliqués Les graphes stockés dans Neptune peuvent comporter des doublons de nœuds ou d'arêtes. Ces éléments redondants introduiront du bruit lors de l'entraînement de modèle ML. Éliminez les doublons de nœuds ou d'arêtes avant d'exporter les données. ## Régler la structure du graphe Lorsque le graphe est exporté, vous pouvez modifier la façon dont les fonctionnalités sont traitées et la façon dont le graphe est construit, afin d'améliorer les performances du modèle. Voici quelques bonnes pratiques : + Lorsqu'une propriété d'arête a la signification de catégories d'arête, il est parfois utile de la transformer en types d'arête. + La politique de normalisation par défaut utilisée pour une propriété numérique est `min-max`, mais dans certains cas, d'autres politiques de normalisation fonctionnent mieux. Vous pouvez prétraiter la propriété et modifier la politique de normalisation comme expliqué dans [Éléments d'un fichier `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements). + Le processus d'exportation génère automatiquement des types de fonctionnalité en fonction des types de propriété. Par exemple, il traite les propriétés `String` comme des fonctionnalités catégorielles et les propriétés `Float` et `Int` comme des fonctionnalités numériques. Si nécessaire, vous pouvez modifier le type de fonctionnalité après l'exportation (voir [Éléments d'un fichier `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)). ## Régler les plages d'hyperparamètres et les valeurs par défaut L'opération de traitement de données déduit des plages de configuration des hyperparamètres à partir du graphe. Si les plages d'hyperparamètres et les valeurs par défaut du modèle généré ne fonctionnent pas correctement pour vos données de graphe, vous pouvez modifier le fichier de configuration HPO afin de créer votre propre stratégie de réglage des hyperparamètres. Voici quelques bonnes pratiques : + Lorsque le graphe devient grand, la taille de la dimension masquée par défaut peut ne pas être suffisante pour contenir toutes les informations. Vous pouvez modifier l'hyperparamètre `num-hidden` pour contrôler la taille de la dimension masquée. + Pour les modèles d'intégration de graphe de connaissances (KGE), vous souhaiterez peut-être modifier le modèle spécifique utilisé en fonction de votre structure de graphe et de votre budget. `TrainsE`les modèles ont du mal à gérer les relations one-to-many (1-N), many-to-one (N-1) et many-to-many (N-N). `DistMult`les modèles ont du mal à gérer les relations symétriques. `RotatE`est bon pour modéliser toutes sortes de relations, mais il est plus coûteux que `TrainsE` et `DistMult` pendant la formation. + Dans certains cas, quand l'identification du nœud et les informations sur les fonctionnalités du nœud sont importantes, vous devez utiliser ``concat-node-embed`` pour indiquer au modèle Neptune ML d'obtenir la représentation initiale d'un nœud en concaténant ses fonctionnalités avec ses intégrations initiales. + Lorsque vous obtenez des performances relativement bonnes sur certains hyperparamètres, vous pouvez ajuster l'espace de recherche des hyperparamètres en fonction de ces résultats. ## Arrêt anticipé du processus d'entraînement de modèle dans Neptune ML L'arrêt anticipé peut réduire de manière significative le temps d'entraînement de modèle et les coûts associés sans dégrader les performances de modèle. Il empêche également le surajustement du modèle aux données d'entraînement. L'arrêt anticipé dépend de mesures régulières des performances du jeu de validation. Initialement, les performances s'améliorent au fur et à mesure de l'entraînement, mais lorsque le modèle commence à être surajusté, elles commencent à décliner à nouveau. La fonctionnalité d'arrêt anticipé identifie le point où le modèle commence à être surajusté et interrompt l'entraînement de modèle à ce stade. Neptune ML surveille les appels des métriques de validation et compare la métrique de validation la plus récente à la moyenne des métriques de validation des **`n`** dernières évaluations, où **`n`** est un nombre défini à l'aide du paramètre `window-for-early-stop`. Dès que la métrique de validation est inférieure à cette moyenne, Neptune ML arrête l'entraînement du modèle et enregistre le meilleur modèle à ce stade. Vous pouvez contrôler l'arrêt anticipé à l'aide des paramètres suivants : + **`window-for-early-stop`** : la valeur de ce paramètre est un entier qui spécifie le nombre de scores de validation récents à moyenner pour décider d'un arrêt anticipé. La valeur par défaut est `3`. + **`enable-early-stop`** : utilisez ce paramètre booléen pour désactiver la fonctionnalité d'arrêt anticipé. Par défaut, cette valeur est `true`. ## Arrêt anticipé du processus HPO dans Neptune ML La fonction d'arrêt anticipé de Neptune ML arrête également les tâches d'entraînement qui ne fonctionnent pas bien par rapport aux autres tâches de formation, à l'aide de la fonction de démarrage à chaud SageMaker AI HPO. Cela peut également réduire les coûts et améliorer la qualité de l'optimisation des hyperparamètres (HPO). Consultez [Exécution d'une tâche de réglage des hyperparamètres avec démarrage à chaud](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html) pour obtenir une description de son fonctionnement. Le démarrage à chaud permet de transmettre les informations apprises à partir des tâches d'entraînement précédentes aux tâches d'entraînement suivantes et offre deux avantages distincts : + Tout d'abord, les résultats des tâches d'entraînement précédentes sont utilisés pour sélectionner de bonnes combinaisons d'hyperparamètres à examiner dans la nouvelle tâche de réglage. + Ensuite, il permet un arrêt anticipé pour accéder à un plus grand nombre d'exécutions de modèle, ce qui réduit le temps de réglage. Cette fonctionnalité est activée automatiquement dans Neptune ML et vous permet de trouver un équilibre entre le temps d'entraînement de modèle et ses performances. Si vous êtes satisfait des performances du modèle actuel, vous pouvez utiliser ce modèle. Sinon, vous en exécutez d'autres HPOs qui démarrent à chaud avec les résultats des essais précédents afin de découvrir un meilleur modèle. ## Bénéficier de services d'assistance professionnels AWS propose des services de support professionnels pour vous aider à résoudre les problèmes liés à vos projets d'apprentissage automatique sur Neptune. Si vous êtes bloqué, contactez [AWS Support](https://aws.amazon.com/premiumsupport/).