Recommandations pour TensorFlow : Entraîner et régler sur AI Platform

Cet article constitue la deuxième partie d'une série de tutoriels en plusieurs parties qui explique comment mettre en œuvre un système de recommandation basé sur le machine learning (ML) avec TensorFlow et AI Platform. Dans cette partie, vous apprendrez à entraîner le système de recommandation et à régler les hyperparamètres à l'aide d'AI Platform dans Google Cloud Platform (GCP).

La série comprend les éléments suivants :

Dans ce tutoriel, nous partons du principe que vous avez terminé les parties précédentes de la série.

Objectifs

  • Découvrez comment exécuter une tâche d'entraînement sur AI Platform pour effectuer des recommandations d'ensembles de données MovieLens.
  • Réglez les hyperparamètres d'AI Platform et optimisez le modèle de recommandation WALS de TensorFlow pour l'ensemble de données MovieLens.

Coûts

Ce tutoriel utilise les services facturables Cloud Storage et AI Platform. Vous pouvez vous servir du simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue. Le coût prévisionnel de ce tutoriel est de 0,20 $. Si vous êtes un nouvel utilisateur de GCP, vous pouvez éventuellement bénéficier d'un essai gratuit.

Avant de commencer

Suivez les instructions de la Partie 1 pour configurer votre projet GCP.

Entraîner le modèle

Le premier tutoriel de cette série s'est penché sur la mise en œuvre de l'algorithme WALS dans TensorFlow. Le présent tutoriel explique comment entraîner le modèle avec AI Platform. Dans ce contexte, "entraîner le modèle" signifie prendre en compte une matrice de notes creuse R dans une matrice de facteurs de l'utilisateur X et une matrice de facteurs de l'élément Y. Les facteurs de l'utilisateur résultants servent de modèle de base pour un système de recommandation.

Vous déploierez le système de recommandation sur GCP dans la Partie 4.

Tâches d'entraînement sur AI Platform

Pour entraîner un modèle avec AI Platform, vous devez spécifier un répertoire de travail, qui est un dossier de bucket Cloud Storage. Pour exécuter une tâche d'entraînement, procédez comme suit :

  1. Créez un bucket Cloud Storage dans votre projet ou utilisez un bucket existant.

    Pour créer un bucket, sélectionnez Stockage > Navigateur dans Cloud Console, puis cliquez sur Créer un bucket.

    Notez bien le nom que vous donnez à ce bucket. Il est judicieux de localiser ce bucket dans la même région que votre instance Compute Engine.

  2. Dans l'interface système, définissez la variable d'environnement BUCKET sur l'URL de bucket Cloud Storage correspondant au bucket que vous utilisez.

    BUCKET=gs://[YOUR_BUCKET_NAME]
  3. Copiez les ensembles de données MovieLens dans le bucket à l'aide de l'outil gsutil :

    gsutil cp -r data/u.data $BUCKET/data/u.data
    gsutil cp -r data/ratings.dat $BUCKET/data/ratings.dat
    gsutil cp -r data/ratings.csv $BUCKET/data/ratings.csv
  4. Exécutez la tâche en exécutant le script d'entraînement dans le répertoire wals_ml_engine, en définissant l'option train et en spécifiant l'URL du bucket Cloud Storage et le chemin d'accès au fichier de données qu'il contient.

    L'ensemble de données que vous utilisez dépend des décisions que vous avez prises dans la Partie 1. Définissez des options supplémentaires correspondant au fichier de données choisi, telles que le délimiteur ou l'en-tête :

    cd wals_ml_engine
    • Pour l'ensemble de données MovieLens 100k, spécifiez le chemin d'accès au fichier de données 100k :

      ./mltrain.sh train ${BUCKET} data/u.data
    • Pour l'ensemble de données 1m, incluez l'option --delimiter et spécifiez le chemin d'accès au fichier de données 1m :

      ./mltrain.sh train ${BUCKET} data/ratings.dat --delimiter ::
    • Pour l'ensemble de données 20m, utilisez les options --delimiter et --headers :

      ./mltrain.sh train ${BUCKET} data/ratings.csv --delimiter , --headers

    Vous pouvez surveiller l'état et le résultat de la tâche sur la page Tâches de la section AI Platform de Cloud Console. Cliquez sur Journaux pour afficher les résultats de la tâche. Les résultats sont consignés sous forme de RMSE (Root Mean Squared Error, ou racine carrée de l'erreur quadratique moyenne) calculée sur l'ensemble de données de test. La RMSE représente l'erreur moyenne, pour l'ensemble de données des notes utilisé pour les tests, sur l'estimation réalisée par le modèle pour les notes des utilisateurs.

Enregistrer le modèle

Après la factorisation, les matrices de facteurs sont enregistrées dans cinq fichiers individuels au format numpy afin de pouvoir être utilisées pour effectuer des recommandations. La Partie 3 de ce tutoriel détaille les fichiers de modèle et vous montre comment les utiliser pour générer des recommandations. La Partie 4 explique comment déployer un système de production pour effectuer des recommandations. Lorsque le modèle est entraîné localement, les fichiers sont enregistrés dans le dossier jobs du package de code. Lorsque le modèle est entraîné sur AI Platform, les fichiers sont enregistrés dans un bucket Cloud Storage fourni par l'argument job-dir de la tâche AI Platform décrite dans la section précédente.

Résultats avec l'ensemble de données MovieLens

Les résultats des approximations de la factorisation matricielle sont basés sur les prédictions de notes réalisées avec l'ensemble de données de test. L'ensemble de données de test est extrait de la matrice de notes lors du prétraitement. Pour calculer la différence entre les notes prédites et les notes réelles attribuées par les utilisateurs, qui figurent dans l'ensemble de données de test, utilisez la formule de perte décrite dans la Partie 1 :

$$ L = \sum_{u,i}(r_{ui} - x^{T}_{u} \cdot y_{i})^{2} $$

Ici, \(r_{ui}\) correspond aux notes figurant dans l'ensemble de test, tandis que \(x_{u}\) et \(y_{i}\) sont les facteurs de ligne et de colonne calculés en appliquant la factorisation WALS à l'ensemble d'entraînement.

Les performances de la factorisation matricielle dépendent fortement de plusieurs hyperparamètres qui sont décrits plus en détail dans la section suivante de ce document. En utilisant l'ensemble de données 1m MovieLens et l'ensemble d'hyperparamètres par défaut répertoriés dans le tableau 1, une RMSE de 1,06 a été obtenue sur l'ensemble de test. La RMSE correspond à l'erreur moyenne relevée dans les prédictions de notes par rapport à l'ensemble de test. En moyenne, chaque note produite par l'algorithme se situe dans une fourchette de plus ou moins 1,06 par rapport à la note de l'utilisateur dans l'ensemble de données de test 1m. Une note de 3 réellement donnée par un utilisateur générera probablement une note estimée comprise entre 2 et 4, mais il est peu probable qu'elle produise 1 ou 5. Ce n'est pas un mauvais résultat, mais les résultats publiés pour cet ensemble de données atteignent une RMSE inférieure à 1,0.

Pour améliorer le résultat, vous devez régler les hyperparamètres répertoriés dans le Tableau 1.

Nom et description de l'hyperparamètre Valeur par défaut Évoluer
latent_factors
Nombre de facteurs latents K
5 UNIT_REVERSE_LOG_SCALE
regularization
Constante de régularisation L2
0,07 UNIT_REVERSE_LOG_SCALE
unobs_weight
Pondération des entrées non observées de la matrice de notes
0,01 UNIT_REVERSE_LOG_SCALE
feature_wt_factor
Pondération des entrées observées
130 UNIT_LINEAR_SCALE
feature_wt_exp
Exposant de pondération des caractéristiques
1 UNIT_LOG_SCALE
num_iters
Nombre d'itérations des moindres carrés alternés
20 UNIT_LINEAR_SCALE

Tableau 1. Noms des hyperparamètres et valeurs par défaut utilisés dans le modèle.

Réglage des hyperparamètres

La recherche du jeu d'hyperparamètres optimal est essentielle pour les performances des modèles de machine learning. Malheureusement, la théorie est un guide limité en la matière. Les data scientists sont contraints d'optimiser en essayant diverses valeurs situées dans des plages raisonnables, en testant les performances ainsi obtenues avec le modèle, puis en sélectionnant une combinaison de paramètres offrant les meilleures performances. Cela peut être un processus long et coûteux en termes d'heures-personnes et de ressources de calcul. L'espace des combinaisons d'hyperparamètres possibles augmente de façon exponentielle en fonction du nombre de paramètres distincts du modèle. Parcourir l'intégralité de cet espace n'est pas faisable. Cela vous oblige à formuler des hypothèses sur les facteurs qui affectent le modèle à partir d'heuristiques, d'une expérience antérieure et de la connaissance des propriétés mathématiques de chaque paramètre.

AI Platform inclut une fonctionnalité de réglage d'hyperparamètre, qui recherche automatiquement un ensemble optimal d'hyperparamètres. Pour utiliser cette fonctionnalité, vous fournissez une liste des hyperparamètres que vous souhaitez régler, ainsi que les plages ou valeurs attendues pour ces paramètres. AI Platform exécute une recherche sur l'espace d'hyperparamètres en exécutant autant d'essais que vous le souhaitez et renvoie une liste classée des résultats obtenus pour les hyperparamètres les plus performants parmi tous les essais réalisés. Vous pouvez fournir l’échelle présumée du paramètre, log ou linéaire, en tant qu’indication supplémentaire pour le processus de recherche.

Pour en savoir plus sur le réglage des hyperparamètres, reportez-vous à la documentation sur AI Platform. Pour plus d'informations sur l'algorithme sous-jacent utilisé pour le réglage d'hyperparamètres, consultez l'article de blog sur le réglage d'hyperparamètres par optimisation bayésienne dans Cloud Machine Learning Engine (en anglais).

Le fichier de configuration des hyperparamètres

La liste des hyperparamètres pour AI Platform peut être fournie dans un fichier de configuration JSON ou YAML. Dans l'exemple de code de ce tutoriel, la configuration des réglages d'hyperparamètres est définie par config/config_tune.json. Chacun des hyperparamètres à régler dans ce tutoriel est répertorié dans ce fichier, ainsi que les valeurs minimales et maximales de la plage attendue et l'échelle. Pour plus d'informations sur les valeurs d'échelle valides pour les paramètres, consultez la présentation des réglages d'hyperparamètres.

Le type de machine standard_gpu est spécifié dans le paramètre scaleTier. Le réglage s'effectue donc sur une machine provisionnée pour le calcul GPU. Le fichier de configuration ressemble à ceci :

{
  "trainingInput":{
    "scaleTier":"CUSTOM",
    "masterType":"standard_gpu",
    "hyperparameters":{
      "goal":"MINIMIZE",
      "params":[
        {
          "parameterName":"regularization",
          "type":"DOUBLE",
          "minValue":"0.001",
          "maxValue":"10.0",
          "scaleType":"UNIT_REVERSE_LOG_SCALE"
        },
        {
          "parameterName":"latent_factors",
          "type":"INTEGER",
          "minValue":"5",
          "maxValue":"50",
          "scaleType":"UNIT_REVERSE_LOG_SCALE"
        },
        {
          "parameterName":"unobs_weight",
          "type":"DOUBLE",
          "minValue":"0.001",
          "maxValue":"5.0",
          "scaleType":"UNIT_REVERSE_LOG_SCALE"
        },
        {
          "parameterName":"feature_wt_factor",
          "type":"DOUBLE",
          "minValue":"1",
          "maxValue":"200",
          "scaleType":"UNIT_LOG_SCALE"
        }
      ],
      "maxTrials":500
    }
  }
}

Code du réglage des hyperparamètres

Le code du modèle inclut les fonctionnalités suivantes pour permettre le réglage des hyperparamètres :

  • Chaque hyperparamètre est transmis en tant qu'argument à la tâche de réglage d'hyperparamètres sur AI Platform. Dans ce cas, le fichier task.py, qui sert de point d'entrée à la tâche, traite les arguments relatifs aux hyperparamètres. Vous devez vous assurer que le nom de l'argument correspond au nom de l'hyperparamètre, tel qu'indiqué dans le fichier de configuration des hyperparamètres.
  • Le modèle écrit un résumé TensorFlow avec un tag spécial, training/hptuning/metric, défini sur la métrique qui évalue la qualité du modèle. Dans le cas présent, RMSE est la métrique de l'ensemble de test. Cette métrique récapitulative permet au processus de recherche du service de réglage d'hyperparamètres d'AI Platform de classer les différents essais. La valeur de la métrique summary est écrite dans une fonction utilitaire dans util.py :

    summary = Summary(value=[Summary.Value(tag='training/hptuning/metric',
                                           simple_value=metric)])
    
    eval_path = os.path.join(args['output_dir'], 'eval')
    summary_writer = tf.summary.FileWriter(eval_path)
    
    # Note: adding the summary to the writer is enough for hyperparam tuning.
    # The ml engine system is looking for any summary added with the
    # hyperparam metric tag.
    summary_writer.add_summary(summary)
  • Il est important de disposer d'un répertoire de sortie distinct pour chaque essai. Le répertoire de sortie est utilisé pour écrire le résumé TensorFlow ainsi que le modèle enregistré. Si vous ne créez pas un répertoire de sortie distinct pour chaque essai, les résultats de chaque essai écrasent ceux de l'essai précédent. La création d'un répertoire unique pour chaque essai est gérée dans task.py par le code suivant dans la méthode parse_arguments :

    if args.hypertune:
      # if tuning, join the trial number to the output path
      trial = json.loads(os.environ.get('TF_CONFIG', '{}')).get('task', {}).get('trial', '')
      output_dir = os.path.join(job_dir, trial)
    else:
      output_dir = os.path.join(job_dir, args.job_name)

    Ici, la fonction parse_arguments fait la distinction entre le réglage et la sortie standard, et modifie output_dir en conséquence.

Exécuter la tâche de réglage des hyperparamètres

La commande suivante exécute la tâche de réglage sur l'ensemble de données 100k :

./mltrain.sh tune $BUCKET data/u.data

Assurez-vous que la variable BUCKET est bien définie sur le bucket que vous avez créé précédemment. La petite taille de l'ensemble de données 100k autorise l'exécution d'un grand nombre d'essais (500, dans le cas présent).

Résultats du réglage

Les résultats des réglages des hyperparamètres sont stockés dans les données des tâches AI Platform, auxquelles vous pouvez accéder sur la page Tâches de la section AI Platform de Cloud Console. Comme vous pouvez le constater dans la Figure 1, les résultats de la tâche incluent le meilleur score RMSE réalisé sur l'ensemble des essais pour la métrique récapitulative. Vous pouvez voir les résultats des réglages des hyperparamètres pour 500 essais réalisés sur l'ensemble de données 100k MovieLens. Les meilleurs résultats ont été obtenus lors de l'essai 384.

Résultats de la tâche de réglage des hyperparamètres, soulignant les résultats de la tâche 384
Figure 1 Résultats de la tâche de réglage des hyperparamètres

Le réglage des hyperparamètres peut faire une grande différence dans les résultats finaux. Dans ce cas, les réglages d'hyperparamètres sur l'ensemble de test 100k ont obtenu une RMSE de 0,98. L'application de ces paramètres aux ensembles de données 1m et 20m a donné lieu à des valeurs RMSE respectives de 0,90 et de 0,88. Les paramètres optimaux sont répertoriés dans le Tableau 2, et les valeurs de RMSE avant et après le réglage sont résumées dans le Tableau 3.

Nom de l'hyperparamètre Description Valeur de réglage
latent_factors Facteurs latents K 34
regularization Constante de régularisation L2 9,83
unobs_weight Pondération des valeurs non observées 0,001
feature_wt_factor Pondération des valeurs observées 189,8
feature_wt_exp Exposant de pondération des caractéristiques ND
num_iters Nombre d'itérations ND

Tableau 2. Valeurs découvertes par le réglage des hyperparamètres d'AI Platform

L'exposant de pondération des caractéristiques ne fait pas partie des paramètres de réglage, car la pondération linéaire observée est utilisée pour l'ensemble de données MovieLens. La valeur par défaut a été utilisée pour num_iters, le paramètre du nombre d'itérations.

Ensemble de données RMSE avec les hyperparamètres par défaut RMSE après le réglage des hyperparamètres
100k 1,06 0,98
1m 1,11 0,90
20m 1,30 0,88

Tableau 3. Résumé des valeurs RMSE de l'ensemble de test pour les différents ensembles de données MovieLens, avant et après les réglages d'hyperparamètres.

Étape suivante

La page Recommandations avec TensorFlow : Appliquer le modèle aux données provenant de Google Analytics (Partie 3) de la solution vous montre comment appliquer ce modèle de recommandations à des données réelles issues de Google Analytics.