Développement de modèle personnalisé dans Neptune ML

Une bonne manière de démarrer le développement de modèle personnalisé consiste à suivre les exemples de la boîte à outils Neptune ML pour structurer et écrire votre module d'entraînement. La boîte à outils Neptune ML implémente également des composants de modèle ML de graphe modulaire dans l'élément modelzoo que vous pouvez empiler et utiliser pour créer votre modèle personnalisé.

En outre, la boîte à outils fournit des fonctions utilitaires qui vous aident à générer les artefacts nécessaires pendant l'entraînement de modèle et la transformation de modèle. Vous pouvez importer ce package Python dans votre implémentation personnalisée. Toutes les fonctions ou tous les modules fournis dans la boîte à outils sont également disponibles dans l'environnement d'entraînement Neptune ML.

Si votre module Python possède des dépendances externes supplémentaires, vous pouvez les inclure en créant un fichier requirements.txt dans le répertoire de votre module. Les packages répertoriés dans le fichier requirements.txt seront ensuite installés avant l'exécution de votre script d'entraînement.

Au minimum, le module Python qui implémente votre modèle personnalisé doit contenir les éléments suivants :

• Un point d'entrée de script d'entraînement

• Un point d'entrée de script de transformation

• Un fichier model-hpo-configuration.json

Développement d'un script d'entraînement de modèle personnalisé dans Neptune ML

Votre script d'entraînement de modèle personnalisé doit être un script Python exécutable, comme l'exemple train.py de la boîte à outils Neptune ML. Il doit accepter les noms et les valeurs des hyperparamètres en tant qu'arguments de ligne de commande. Pendant l'entraînement de modèle, les noms des hyperparamètres sont obtenus à partir du fichier model-hpo-configuration.json. Les valeurs des hyperparamètres se situent dans la plage des hyperparamètres valides si l'hyperparamètre est réglable, ou prennent la valeur d'hyperparamètre par défaut s'il n'est pas réglable.

Votre script d'entraînement est exécuté sur une instance d'entraînement SageMaker en utilisant une syntaxe comme celle-ci :

python3 (script entry point) --(1st parameter) (1st value) --(2nd parameter) (2nd value) (...)

Pour toutes les tâches, Neptune ML AutoTrainer envoie plusieurs paramètres requis à votre script d'entraînement en plus des hyperparamètres que vous spécifiez, et votre script doit être capable de gérer ces paramètres supplémentaires pour fonctionner correctement.

Ces paramètres obligatoires supplémentaires varient quelque peu en fonction de la tâche :

Pour la classification de nœud ou la régression de nœud

• task : type de tâche utilisé en interne par Neptune ML. Pour la classification de nœud, il s'agit de node_class et, pour la régression de nœud, il s'agit de node_regression.

• model : nom du modèle utilisé en interne par Neptune ML, à savoir custom dans ce cas.

• name : nom de la tâche utilisée en interne par Neptune ML, à savoir node_class-custom pour la classification de nœud dans ce cas, et node_regression-custom pour la régression de nœud.

• target_ntype : nom du type de nœud pour la classification ou la régression.

• property : nom de la propriété de nœud pour la classification ou la régression.

Pour la prédiction de lien

• task : type de tâche utilisé en interne par Neptune ML. Pour la prédiction de lien, il s'agit de link_predict.

• model : nom du modèle utilisé en interne par Neptune ML, à savoir custom dans ce cas.

• name : nom de la tâche utilisée en interne par Neptune ML, à savoir link_predict-custom dans ce cas.

Pour la classification d'arête ou la régression d'arête

• task : type de tâche utilisé en interne par Neptune ML. Pour la classification d'arête, il s'agit de edge_class et, pour la régression d'arête, il s'agit de edge_regression.

• model : nom du modèle utilisé en interne par Neptune ML, à savoir custom dans ce cas.

• name : nom de la tâche utilisée en interne par Neptune ML, à savoir edge_class-custom pour la classification d'arête dans ce cas, et edge_regression-custom pour la régression d'arête.

• target_etype : nom du type d'arête pour la classification ou la régression.

• property : nom de la propriété d'arête pour la classification ou la régression.

Votre script doit enregistrer les paramètres du modèle, ainsi que tous les autres artefacts qui seront nécessaires à la fin de l'entraînement.

Vous pouvez utiliser les fonctions utilitaires de la boîte à outils Neptune ML pour déterminer l'emplacement des données de graphe traitées, l'emplacement où les paramètres de modèle doivent être enregistrés et les périphériques GPU disponibles sur l'instance d'entraînement. Consultez l'exemple de script d'entraînement train.py pour des exemples d'utilisation de ces fonctions utilitaires.

Développement d'un script de transformation de modèle personnalisé dans Neptune ML

Un script de transformation est nécessaire pour tirer parti du flux de travail incrémentiel Neptune ML pour l'inférence de modèle sur des graphes évolutifs sans avoir à réentraîner le modèle. Même si tous les artefacts nécessaires au déploiement de modèle sont générés par le script d'entraînement, vous devez tout de même fournir un script de transformation si vous souhaitez générer des modèles mis à jour sans réentraîner le modèle.

Note

L'inférence inductive en temps réel n'est actuellement pas prise en charge pour les modèles personnalisés.

Votre script de transformation de modèle personnalisé doit être un script Python exécutable, comme l'exemple de script transform.py de la boîte à outils Neptune ML. Comme ce script est invoqué pendant l'entraînement de modèle sans arguments de ligne de commande, tous les arguments de ligne de commande acceptés par le script doivent avoir les valeurs par défaut.

Le script s'exécute sur une instance d'entraînement SageMaker avec une syntaxe similaire à celle-ci :

python3 (your transform script entry point)

Votre script de transformation aura besoin de diverses informations, telles que :

• L'emplacement des données du graphe traité.

• L'emplacement où les paramètres du modèle sont enregistrés et où les nouveaux artefacts de modèle doivent être enregistrés.

• Les appareils disponibles sur l'instance.

• Les hyperparamètres qui ont généré le meilleur modèle.

Ces entrées sont obtenues à l'aide des fonctions utilitaires Neptune ML que votre script peut appeler. Consultez l'exemple de script transform.py de la boîte à outils pour obtenir des exemples de la manière de procéder.

Le script doit enregistrer les intégrations de nœuds, les mappages d'ID de nœud et tous les autres artefacts nécessaires au déploiement du modèle pour chaque tâche. Consultez la documentation sur les artefacts de modèle pour plus d'informations sur les artefacts de modèle requis pour les différentes tâches Neptune ML.

Fichier model-hpo-configuration.json personnalisé dans Neptune ML

Le fichier model-hpo-configuration.json définit les hyperparamètres de votre modèle personnalisé. Il est au même format que le fichier model-hpo-configuration.json utilisé avec les modèles intégrés de Neptune ML et il a priorité sur la version générée automatiquement par Neptune ML et chargée à l'emplacement de vos données traitées.

Lorsque vous ajoutez un nouvel hyperparamètre à votre modèle, vous devez également ajouter une entrée pour l'hyperparamètre dans ce fichier afin que l'hyperparamètre soit transmis à votre script d'entraînement.

Vous devez fournir une plage pour un hyperparamètre si vous souhaitez qu'il soit réglable et le définir en tant que paramètre tier-1, tier-2 ou tier-3. L'hyperparamètre sera réglé si le nombre total de tâches d'entraînement configurées permet de régler les hyperparamètres de son niveau. Pour un paramètre non réglable, vous devez fournir une valeur par défaut et ajouter l'hyperparamètre dans la section fixed-param du fichier. Consultez le fichier d'exemple model-hpo-configuration.json de la boîte à outils pour obtenir un exemple de la procédure à suivre.

Vous devez également fournir la définition de métrique que la tâche d'optimisation des hyperparamètres de SageMaker utilisera pour évaluer les modèles candidats entraînés. Pour ce faire, vous devez ajouter un objet JSON eval_metric dans le fichier model-hpo-configuration.json comme suit :

"eval_metric": {
  "tuning_objective": {
      "MetricName": "(metric_name)",
      "Type": "Maximize"
  },
  "metric_definitions": [
    {
      "Name": "(metric_name)",
      "Regex": "(metric regular expression)"
    }
  ]
},

Le tableau metric_definitions figurant dans l'objet eval_metric répertorie les objets de définition de métrique pour chaque métrique que vous souhaitez que SageMaker extraie de l'instance d'entraînement. Chaque objet de définition de métrique possède une clé Name qui vous permet de donner un nom à la métrique (par exemple « précision », « f1 », etc.). La clé Regex vous permet de fournir une chaîne d'expression régulière correspondant à la manière dont cette métrique particulière est imprimée dans les journaux d'entraînement. Consultez la page de réglage des hyperparamètres SageMaker pour plus de détails sur la façon de définir les métriques.

L'objet tuning_objective dans eval_metric vous permet ensuite de spécifier quelle métrique de metric_definitions doit être utilisée comme métrique d'évaluation servant de métrique d'objectif pour l'optimisation des hyperparamètres. La valeur de MetricName doit correspondre à la valeur d'un élément Name dans l'une des définitions de metric_definitions. La valeur de Type doit être « Maximiser » ou « Minimiser » selon qu'il faille interpréter la métrique comme « plus la valeur est grande, mieux c'est » (comme avec « précision ») ou comme « moins la valeur est grande, mieux c'est » (comme avec « erreur quadratique moyenne »).

Les erreurs contenues dans cette section du fichier model-hpo-configuration.json peuvent entraîner des échecs de la tâche d'API d'entraînement de modèle Neptune ML, car la tâche de réglage des hyperparamètres SageMaker ne sera pas en mesure de sélectionner le meilleur modèle.

Test local de l'implémentation de votre modèle personnalisé dans Neptune ML

Vous pouvez utiliser l'environnement Conda de la boîte à outils Neptune ML pour exécuter votre code localement afin de tester et de valider votre modèle. Si vous effectuez le développement sur une instance de bloc-notes Neptune, cet environnement Conda sera préinstallé sur l'instance de bloc-notes Neptune. Si vous effectuez le développement sur une autre instance, vous devez suivre les instructions de configuration locale (langue française non garantie) de la boîte d'outils Neptune ML.

L'environnement Conda reproduit avec précision l'environnement dans lequel votre modèle sera exécuté lorsque vous appellerez l'API d'entraînement de modèle. Tous les exemples de scripts d'entraînement et de transformation vous permettent de transmettre un indicateur --local de ligne de commande pour exécuter les scripts dans un environnement local afin de faciliter le débogage. Il s'agit d'une bonne pratique lors du développement de votre propre modèle, car cela vous permet de tester l'implémentation de votre modèle de manière interactive et itérative. Lors de l'entraînement de modèle dans l'environnement d'entraînement de production Neptune ML, ce paramètre est omis.