Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML - Amazon Neptune
Structure de fichierPersonnalisation des hyperparamètres

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.

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 précédente. Il utilise ces 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 SageMaker afin d'entraîner plusieurs modèles pour votre tâche. 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 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 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. 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.

    • "mse" : métrique d'erreur quadratique moyenne pour les tâches de régression.

    • "mrr" : métrique de rang réciproque moyen.

    • "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. 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 d'entraînement lancées par la tâche de réglage d'hyperparamètres de SageMaker. 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.

  • 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éfinition d'une valeur beaucoup plus élevée sans réduire batch-size peut entraîner des problèmes de mémoire insuffisante lors de l'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. Voir aussi Arrêt anticipé du processus d'entraînement de modèle dans Neptune ML. Type : int. Par défaut : 3.

    Voir .

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 minimum et/ou maximum des hyperparamètres range.

  • 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.