Entraînement de NCF sur Cloud TPU (TF 2.x)

Présentation

Il s'agit d'une mise en œuvre du framework de filtrage collaboratif neuronal (NCF) à l'aide d'un modèle de factorisation matricielle neuronale (NeuMF), comme décrit dans l'article relatif au filtrage collaboratif neuronal. L'implémentation actuelle est basée sur le code issu du code NFC de l'auteur et sur l'implémentation de Stanford dans le dépôt MLPerf.

NCF propose un framework pour faciliter le filtrage collaboratif des recommandations dans lesquelles une architecture de réseau de neurones est utilisée pour modéliser les interactions entre éléments. Contrairement aux modèles traditionnels, le NCF n'a pas recours à la factorisation matricielle (MF) avec un produit interne sur les caractéristiques latentes des utilisateurs et des éléments. Il remplace le produit interne par un perceptron à plusieurs couches capable d'apprendre une fonction arbitraire à partir de données.

Les deux implémentations de NCF sont l'implémentation GMF (Generalized Matrix Factorization) et MLP (Multi-Layer Perceptron) GMF applique un noyau linéaire pour modéliser les interactions de caractéristiques latentes, et MLP utilise un noyau non linéaire pour apprendre la fonction d'interaction à partir des données. NeuMF est un modèle fusionné de GMF et MLP pour mieux modéliser les interactions complexes des éléments utilisateur, et unifie les atouts de la linéarité de MF et la non-linéarité de MLP pour modéliser les structures latentes des éléments utilisateur. NeuMF permet à GMF et MLP d'apprendre des représentations vectorielles continues distinctes et combine les deux modèles en concaténant leur dernière couche cachée. neumf_model.py définit les détails de l'architecture.

Les instructions ci-dessous supposent que vous savez comment entraîner un modèle sur Cloud TPU. Si vous débutez avec Cloud TPU, consultez le guide de démarrage rapide pour en savoir plus.

Dataset

Les ensembles de données MovieLens sont utilisés pour l'évaluation et l'entraînement des modèles. Plus précisément, nous utilisons deux ensembles de données : ml-1m (abréviation de "MovieLens 1 million") et ml-20m (abréviation de "MovieLens 20 million").

ml-1m

L'ensemble de données ml-1m contient 1 000 209 notes anonymes d'environ 3 066 films réalisés par 6 040 utilisateurs, qui ont rejoint MovieLens en 2000. Toutes les notes sont contenues dans le fichier "ratings.dat" sans ligne d'en-tête et sont au format suivant :

UserID::MovieID::Rating::Timestamp

  • Les ID utilisateur sont compris entre 1 et 6040.
  • Les MovieID sont compris entre 1 et 3952.
  • Les notes sont basées sur une échelle de cinq étoiles (attribution d'étoiles entières uniquement).

ml-20m

L'ensemble de données ml-20m contient 20 000 263 notes de 138 493 utilisateurs sur 26 744 films. Tous les avis sont inclus dans le fichier "ratings.csv". Chaque ligne de ce fichier située après la ligne d'en-tête représente la note d'un utilisateur pour un film et se présente au format suivant:

userId,movieId,rating,timestamp

Les lignes de ce fichier sont triées d'abord par userId, puis, pour chaque utilisateur, par movieId. Les notes sont basées sur une échelle de cinq étoiles, avec une incrémentation par demi-étoile (de 0,5 étoile à cinq étoiles). Dans les deux ensembles de données, l'horodatage est représenté en secondes depuis minuit en temps universel coordonné (UTC) du 1er janvier 1970. Chaque utilisateur a au moins 20 notes.

Objectifs

  • Créer un bucket Cloud Storage pour stocker votre ensemble de données et la sortie du modèle
  • Préparer l'ensemble de données MovieLens
  • Configurer une VM Compute Engine et un nœud Cloud TPU pour l'entraînement et l'évaluation
  • Exécuter l'évaluation et l'entraînement

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • Instance
  • Cloud TPU
  • Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Avant de commencer ce tutoriel, vérifiez que votre projet Google Cloud est correctement configuré.

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  5. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  6. Ce tutoriel utilise des composants facturables de Google Cloud. Consultez la grille tarifaire de Cloud TPU pour estimer vos coûts. Veillez à nettoyer les ressources que vous avez créées lorsque vous avez terminé, afin d'éviter des frais inutiles.

Configurer vos ressources

Cette section fournit des informations sur la configuration des ressources Cloud Storage, de VM et Cloud TPU pour ce tutoriel.

  1. Ouvrez une fenêtre Cloud Shell.

    Ouvrir Cloud Shell

  2. Créez une variable d'environnement pour l'ID de votre projet.

    export PROJECT_ID=project-id
  3. Configurez l'outil de ligne de commande gcloud pour utiliser le projet dans lequel vous souhaitez créer une Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    

    La première fois que vous exécutez cette commande dans une nouvelle VM Cloud Shell, une page Authorize Cloud Shell s'affiche. Cliquez sur Authorize en bas de la page pour permettre à gcloud d'effectuer des appels d'API GCP avec vos identifiants.

  4. Créez un compte de service pour le projet Cloud TPU.

    gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID
    

    La commande renvoie un compte de service Cloud TPU au format suivant :

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    
  5. Créez un bucket Cloud Storage à l'aide de la commande suivante :

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 gs://bucket-name
    

    Ce bucket Cloud Storage stocke les données que vous utilisez pour entraîner votre modèle, ainsi que les résultats de l'entraînement. La commande gcloud utilisée dans ce tutoriel pour configurer le TPU configure également les autorisations par défaut pour le compte de service Cloud TPU que vous avez configuré à l'étape précédente. Si vous souhaitez utiliser des autorisations plus précises, vérifiez les autorisations de niveau d'accès.

    L'emplacement du bucket doit se trouver dans la même région que votre machine virtuelle (VM) et votre nœud TPU. Les VM et les nœuds TPU sont situés dans des zones spécifiques, qui sont des subdivisions au sein d'une région.

  6. Lancez une VM Compute Engine et Cloud TPU à l'aide de la commande gcloud. La commande utilisée varie selon que vous utilisez des VM TPU ou des nœuds TPU. Pour en savoir plus sur l'architecture des deux VM, consultez la page Architecture système.

    VM TPU

    $ gcloud alpha compute tpus tpu-vm create ncf-tutorial \
    --zone=europe-west4-a \
    --accelerator-type=v3-8 \
    --version=v2-alpha
    

    Description des options de commande

    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    accelerator-type
    Type du Cloud TPU à créer.
    version
    Version d'exécution de Cloud TPU.

    Nœud TPU

    $ gcloud compute tpus execution-groups create  \
     --zone=europe-west4-a \
     --name=ncf-tutorial \
     --accelerator-type=v3-8 \
     --machine-type=n1-standard-8 \
     --disk-size=300 \
     --tf-version=2.6.0
    

    Description des options de commande

    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    name
    Nom du TPU. Si aucune valeur n'est spécifiée, le nom d'utilisateur est utilisé par défaut.
    accelerator-type
    Type du Cloud TPU à créer.
    machine-type
    Type de machine de la VM Compute Engine à créer.
    disk-size
    Taille du volume racine de votre VM Compute Engine (en Go).
    tf-version
    La version de Tensorflow que gcloud installe sur la VM.

    Pour en savoir plus sur la commande gcloud, consultez la documentation de référence de gcloud.

  7. Si vous n'êtes pas automatiquement connecté à l'instance Compute Engine, connectez-vous en exécutant la commande ssh suivante. Lorsque vous êtes connecté à la VM, votre invite d'interface système passe de username@projectname à username@vm-name:

    VM TPU

    gcloud alpha compute tpus tpu-vm ssh ncf-tutorial --zone=europe-west4-a
    

    Nœud TPU

    gcloud compute ssh ncf-tutorial --zone=europe-west4-a
    

Préparer les données

  1. Ajoutez une variable d'environnement pour votre bucket de stockage. Remplacez bucket-name par le nom de votre bucket.

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
  2. Ajoutez une variable d'environnement pour le répertoire de données.

    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
    
  3. Configurez l'emplacement du modèle et définissez la variable d'environnement PYTHONPATH.

    VM TPU

    (vm)$ git clone https://github.com/tensorflow/models.git
    (vm)$ pip3 install -r models/official/requirements.txt
    
    (vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"
    

    Nœud TPU

    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
    (vm)$ pip3 install -r /usr/share/models/official/requirements.txt
    
  4. Accédez au répertoire qui stocke les fichiers de traitement du modèle:

    VM TPU

    (vm)$ cd ~/models/official/recommendation
    

    Nœud TPU

    (vm)$ cd /usr/share/models/official/recommendation
    
  5. Générez des données d'entraînement et d'évaluation pour l'ensemble de données ml-20m dans DATA_DIR :

    (vm)$ python3 create_ncf_data.py \
        --dataset ml-20m \
        --num_train_epochs 4 \
        --meta_data_file_path ${DATA_DIR}/metadata \
        --eval_prebatch_size 160000 \
        --data_dir ${DATA_DIR}
    

Ce script génère et prétraite l'ensemble de données sur votre VM. Le prétraitement convertit les données au format TFRecord requis par le modèle. Le téléchargement et le prétraitement prennent environ 25 minutes, et génèrent un résultat semblable à celui-ci :

I0804 23:03:02.370002 139664166737728 movielens.py:124] Successfully downloaded /tmp/tmpicajrlfc/ml-20m.zip 198702078 bytes
I0804 23:04:42.665195 139664166737728 data_preprocessing.py:223] Beginning data preprocessing.
I0804 23:04:59.084554 139664166737728 data_preprocessing.py:84] Generating user_map and item_map...
I0804 23:05:20.934210 139664166737728 data_preprocessing.py:103] Sorting by user, timestamp...
I0804 23:06:39.859857 139664166737728 data_preprocessing.py:194] Writing raw data cache.
I0804 23:06:42.375952 139664166737728 data_preprocessing.py:262] Data preprocessing complete. Time: 119.7 sec.
%lt;BisectionDataConstructor(Thread-1, initial daemon)>
General:
  Num users: 138493
  Num items: 26744

Training:
  Positive count:          19861770
  Batch size:              99000
  Batch count per epoch:   1004

Eval:
  Positive count:          138493
  Batch size:              160000
  Batch count per epoch:   866

I0804 23:07:14.137242 139664166737728 data_pipeline.py:887] Negative total vector built. Time: 31.8 seconds
I0804 23:11:25.013135 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 250.9 seconds
I0804 23:15:46.391308 139664166737728 data_pipeline.py:674] Eval construction complete. Time: 261.4 seconds
I0804 23:19:54.345858 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 248.0 seconds
I0804 23:24:09.182484 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 254.8 seconds
I0804 23:28:26.224653 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 257.0 seconds

Configurer et démarrer l'entraînement de Cloud TPU

  1. Définissez la variable de nom Cloud TPU.

    VM TPU

    (vm)$ export TPU_NAME=local
    

    Nœud TPU

    (vm)$ export TPU_NAME=ncf-tutorial
    

Exécuter l'entraînement et l'évaluation

Le script suivant exécute un exemple d'entraînement pour trois époques.

  1. Ajoutez une variable d'environnement pour le répertoire "Model" afin d'enregistrer les points de contrôle et les résumés TensorBoard :

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/ncf
    
  2. Exécutez la commande suivante pour entraîner le modèle NCF :

    (vm)$ python3 ncf_keras_main.py \
         --model_dir=${MODEL_DIR} \
         --data_dir=${DATA_DIR} \
         --train_dataset_path=${DATA_DIR}/training_cycle_*/* \
         --eval_dataset_path=${DATA_DIR}/eval_data/* \
         --input_meta_data_path=${DATA_DIR}/metadata \
         --learning_rate=3e-5 \
         --train_epochs=3 \
         --dataset=ml-20m \
         --eval_batch_size=160000 \
         --learning_rate=0.00382059 \
         --beta1=0.783529 \
         --beta2=0.909003 \
         --epsilon=1.45439e-07 \
         --dataset=ml-20m \
         --num_factors=64 \
         --hr_threshold=0.635 \
         --keras_use_ctl=true \
         --layers=256,256,128,64 \
         --use_synthetic_data=false \
         --distribution_strategy=tpu \
         --download_if_missing=false
     

L'entraînement et l'évaluation prennent environ deux minutes et génèrent un résultat final semblable à ce qui suit :

Result is {'loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.10950611>,
'train_finish_time': 1618016422.1377568, 'avg_exp_per_second': 3062557.5070816963}

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

  1. Déconnectez-vous de l'instance Compute Engine, si vous ne l'avez pas déjà fait :

    (vm)$ exit
    

    Votre invite devrait maintenant être username@projectname, indiquant que vous êtes dans Cloud Shell.

  2. Supprimez vos ressources Cloud TPU et Compute Engine. La commande utilisée pour supprimer vos ressources varie selon que vous utilisez des VM TPU ou des nœuds TPU. Pour en savoir plus, consultez la section Architecture système.

    VM TPU

    $ gcloud alpha compute tpus tpu-vm delete ncf-tutorial \
    --zone=europe-west4-a
    

    Nœud TPU

    $ gcloud compute tpus execution-groups delete ncf-tutorial \
    --zone=europe-west4-a
    
  3. Vérifiez que les ressources ont été supprimées en exécutant gcloud compute tpus execution-groups list. La suppression peut prendre plusieurs minutes. Une réponse semblable à celle ci-dessous indique que vos instances ont bien été supprimées.

    VM TPU

    $ gcloud alpha compute tpus tpu-vm list \
    --zone=europe-west4-a
    

    Nœud TPU

    $ gcloud compute tpus execution-groups list --zone=europe-west4-a
    
    Listed 0 items.
    
  4. Exécutez gsutil comme indiqué, en remplaçant bucket-name par le nom du bucket Cloud Storage que vous avez créé pour ce tutoriel :

    $ gsutil rm -r gs://bucket-name
    

Étape suivante

Dans ce tutoriel, vous avez entraîné le modèle NCF à l'aide d'un exemple d'ensemble de données. Les résultats de cet entraînement ne sont pas utilisables pour l'inférence dans la plupart des cas. Afin d'utiliser un modèle pour l'inférence, vous pouvez entraîner les données sur un ensemble de données accessible au public ou sur votre propre ensemble de données. Les modèles entraînés sur des appareils Cloud TPU nécessitent des ensembles de données au format TFRecord.

Vous pouvez utiliser l'exemple d'outil de conversion d'ensemble de données pour convertir un ensemble de données de classification d'images au format TFRecord. Si vous n'utilisez pas de modèle de classification d'images, vous devez convertir vous-même votre ensemble de données au format TFRecord. Pour en savoir plus, consultez TFRecord et tf.Example.

Réglages d'hyperparamètres

Pour améliorer les performances du modèle avec votre ensemble de données, vous pouvez régler ses hyperparamètres. Vous trouverez des informations sur les hyperparamètres communs à tous les modèles compatibles avec des TPU sur GitHub. Des informations sur les hyperparamètres spécifiques au modèle sont disponibles dans le code source de chaque modèle. Pour en savoir plus sur ces réglages, consultez les pages Présentation des réglages d'hyperparamètres, Utiliser le service de réglage d'hyperparamètres et Régler les hyperparamètres.

Inférence

Une fois que vous avez entraîné votre modèle, vous pouvez l'utiliser pour l'inférence (également appelée prédiction). AI Platform est une solution basée sur le cloud permettant de développer, d'entraîner et de déployer des modèles de machine learning. Une fois un modèle déployé, vous pouvez utiliser le service AI Platform Prediction.