Cette page a été traduite par l'API Cloud Translation.

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

Présentation

Il s'agit d'une implémentation du framework de filtrage collaboratif neuronal (NCF) à l'aide d'un modèle de factorisation matricielle neuronale (NeuMF) Article sur le filtrage collaboratif neuronal L'implémentation actuelle est basée sur le code de l'éditeur le code NCF et l'implémentation de Stanford dans le dépôt MLPerf.

Il s'agit d'un framework général permettant de filtrer les recommandations de façon collaborative une architecture de réseau de neurones est utilisée pour modéliser les interactions utilisateur-élément. NCF 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 la couche latente interactions entre les caractéristiques, et le MLP utilise un noyau non linéaire pour apprendre l'interaction à partir de données. NeuMF est un modèle qui combine GMF et MLP afin de mieux modéliser des interactions complexes entre les éléments utilisateur et les éléments, et qui unifie les forces de linéarité des non-linéarité du MLP pour modéliser les structures latentes de l'élément utilisateur. NeuMF permet à GMF et MLP d'apprendre des représentations vectorielles continues distinctes, puis combine les deux modèles concaténant leur dernière couche cachée. neumf_model.py définit les détails de l'architecture.

Les instructions suivantes supposent que vous savez entraîner un modèle Cloud TPU. Si vous débutez avec Cloud TPU, consultez Lancez-vous pour une introduction aux principes de base.

Ensemble de données

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

ml-1m

L'ensemble de données ML-1M contient 1 000 209 notes anonymes sur environ 3 706 films. réalisé par 6 040 utilisateurs qui ont rejoint MovieLens en 2000. Toutes les classifications 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 seul utilisateur pour un film. le format suivant:

userId,movieId,rating,timestamp

Les lignes dans ce fichier sont d'abord triées par userId, puis, dans user, par movieId. La notation est basée sur une échelle de 5 étoiles, avec des incréments d'une demi-étoile. (entre 0,5 et 5 étoiles). Dans les deux ensembles de données, le code temporel est représenté secondes depuis le 1er janvier 1970 à minuit (UTC). Chaque L'utilisateur a reçu 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

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Compute Engine
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é.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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.

Ouvrez une fenêtre Cloud Shell.

Ouvrir Cloud Shell
Créez une variable d'environnement pour l'ID de votre projet.
```
export PROJECT_ID=project-id
```
Configurez la Google Cloud CLI pour utiliser le projet dans lequel vous souhaitez créer la Cloud TPU.
```
gcloud config set project ${PROJECT_ID}
```
La première fois que vous exécutez cette commande dans une nouvelle VM Cloud Shell, La page Autoriser Cloud Shell s'affiche. Cliquez sur Autoriser en bas de la page pour autoriser gcloud à effectuer des appels d'API avec vos identifiants.

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

Créez un bucket Cloud Storage à l'aide de la commande suivante :

Remarque :Dans la commande suivante, remplacez bucket-name par le nom que vous souhaitez attribuer à votre bucket.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
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 du 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 VM TPU. Les VM TPU sont situées dans des zones spécifiques, sous-divisions d'une région.
Créer une VM Cloud TPU
```
$ gcloud compute tpus tpu-vm create ncf-tutorial \
  --zone=europe-west4-a \
  --accelerator-type=v3-8 \
  --version=tpu-vm-tf-2.17.0-pjrt
```
Description des options de commande

zone

Zone dans laquelle vous prévoyez de créer votre Cloud TPU.

accelerator-type

Le type d'accélérateur spécifie la version et la taille de la ressource Cloud TPU que vous souhaitez créer. Pour en savoir plus sur les types d'accélérateurs compatibles avec chaque version de TPU, consultez Versions de TPU.

version

Version logicielle de Cloud TPU.

Remarque : Si vous avez plusieurs projets, vous devez spécifier l'ID du projet avec l'option --project.

Pour en savoir plus sur la commande gcloud, consultez la documentation de référence de gcloud.
Remarque : La première fois que vous exécutez gcloud compute tpus sur un projet, les tâches de démarrage, telles que la propagation de clé SSH et l'activation de l'API, prennent environ cinq minutes.
Connectez-vous à l'instance Compute Engine à l'aide de SSH. Lorsque vous êtes connecté à la VM, l'invite de l'interface système passe de username@projectname à username@vm-name:
```
gcloud compute tpus tpu-vm ssh ncf-tutorial --zone=europe-west4-a
```
Important :À partir de ce moment-là, le préfixe (vm) $ signifie que vous devez exécutez la commande sur l'instance de VM Compute Engine.

Préparer les données

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
```
Ajoutez une variable d'environnement pour le répertoire de données.
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
```

Configurez l'emplacement du modèle et définissez PYTHONPATH variable d'environnement.

(vm)$ git clone https://github.com/tensorflow/models.git
(vm)$ pip3 install -r models/official/requirements.txt

(vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"

Accédez au répertoire où sont stockés les fichiers de traitement du modèle :
```
  (vm)$ cd ~/models/official/recommendation
```
Générez des données d'entraînement et d'évaluation pour l'ensemble de données ml-20m dans DATA_DIR :

Remarque :Vous pouvez ajouter au début de la commande de téléchargement nohup ou utilisez l'écran pour éviter la fermeture du téléchargement en cas de déconnexion de Cloud Shell.
```
(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. Prétraitement convertit les données au format TFRecord requis par le modèle. Le téléchargement et le prétraitement prend environ 25 minutes et génère un résultat semblable à les éléments suivants:

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

Définissez la variable de nom Cloud TPU.
```
  (vm)$ export TPU_NAME=local
```

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

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

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
```
Lors de la création de votre TPU, si vous définissez le paramètre --version sur une version se terminant par -pjrt, définissez les variables d'environnement suivantes pour activer l'environnement d'exécution PJRT:
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```

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.

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.

Supprimez vos ressources Cloud TPU.

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

Vérifiez que les ressources ont été supprimées en exécutant la commande gcloud compute tpus tpu-vm list. La suppression peut prendre plusieurs minutes. Une réponse de ce type indique vos instances ont bien été supprimées.
```
  $ gcloud compute tpus tpu-vm list \
    --zone=europe-west4-a
```
```
Listed 0 items.
```
Exécutez la gcloud CLI comme indiqué, en remplaçant bucket-name par nom du bucket Cloud Storage que vous avez créé pour ce tutoriel:
```
$ gcloud storage rm gs://bucket-name --recursive
```

Étape suivante

Les tutoriels TensorFlow Cloud TPU permettent généralement d'entraîner le modèle à 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. À utiliser un modèle pour l'inférence, vous pouvez entraîner les données sur une couche ensemble de données ou votre propre jeu de données. Modèles TensorFlow entraînés sur des Cloud TPU nécessitent généralement des jeux de données TFRecord.

Vous pouvez utiliser l'outil de conversion des ensembles de données exemple pour convertir une image de classification au format TFRecord. Si vous n'utilisez pas d'image vous devrez convertir votre ensemble de données Format TFRecord vous-même. Pour en savoir plus, consultez les sections 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 hyperparamètres. Vous trouverez des informations sur les hyperparamètres communs à tous Modèles compatibles TPU sur GitHub Pour en savoir plus sur les hyperparamètres propres au modèle, consultez la source de code pour chaque du modèle de ML. Pour en savoir plus sur le réglage des hyperparamètres, consultez la section Présentation réglage des hyperparamètres et régler hyperparamètres.

Inférence

Une fois votre modèle entraîné, vous pouvez l'utiliser pour l'inférence (également appelée des prédictions). Vous pouvez utiliser le convertisseur d'inférence Cloud TPU de Google pour préparer et optimiser Modèle TensorFlow pour l'inférence sur Cloud TPU v5e. Pour plus à propos de l'inférence sur Cloud TPU v5e, consultez la page Inférence Cloud TPU v5e présentation.

En savoir plus sur ctpu, y compris sur la façon de l'installer sur un ordinateur local.
Découvrez les outils TPU dans TensorBoard.