NCF auf Cloud TPU trainieren (TF 2.x)

Übersicht

Dies ist eine Implementierung des Frameworks für neuronale kollaborative Filterung (Neural Collaborative Filtering, NCF) mit einem neuronalen Matrixfaktorisierungs-Modell (Neural Matrix Factorization-Modell, NeuMF), wie im Artikel zur neuronalen kollaborativen Filterung beschrieben. Die aktuelle Implementierung basiert auf dem Code der NCF-Code und Stanford-Implementierung im MLPerf-Repository.

NCF ist ein allgemeines Framework für das kollaborative Filtern von Empfehlungen in in dem eine neuronale Netzwerkarchitektur zur Modellierung von Nutzer-Artikel-Interaktionen verwendet wird. NCF ersetzt das innere Produkt durch einen mehrschichtigen Perceptron, der eine beliebige Funktion aus Daten lernen kann.

Zwei Implementierungen von NCF sind Generalisierte Matrixfaktorfaktorisierung (GMF) und Multi-Layer Perceptron (MLP). GMF wendet einen linearen Kernel an, um die verspäteten Funktionsinteraktionen zu modellieren. MLP verwendet einen nicht linearen Kernel, um die Interaktionsfunktion aus Daten zu lernen. NeuMF ist ein zusammengeführtes Modell von GMF und MLP, mit dem komplexe Nutzerinteraktionen besser modelliert werden können. Außerdem wird die Stärke der Linearität von MF und nicht linearer Form der MLP-Modelle für die Modellierung der spätesten Strukturen der Nutzerelemente kombiniert. Mit NeuMF und GMP können GM und MLP unterschiedliche Einbettungen lernen und die beiden Modelle durch Verknüpfen der letzten verborgenen Ebene verbinden. neumf_model.py definiert die Architekturdetails.

In der folgenden Anleitung wird davon ausgegangen, dass Sie mit dem Trainieren eines Modells auf Cloud TPU vertraut sind. Wenn Sie Cloud TPU noch nicht kennen, finden Sie unter Erste Schritte eine grundlegende Einführung.

Dataset

Die MovieLens-Datasets werden für das Modelltraining und die Bewertung verwendet. Wir verwenden zwei Datasets: ml-1m (kurz für MovieLens 1 Million) und ml-20m (kurz für MovieLens) 20 Millionen).

ml-1m

Das ml-1m-Dataset enthält 1.000.209 anonyme Bewertungen von etwa 3.706 Filmen von 6.040 Nutzern,die 2000 bei MovieLens angemeldet waren. Alle Bewertungen sind in der Datei „ratings.dat“ ohne Kopfzeile enthalten und haben folgendes Format:

UserID::MovieID::Rating::Timestamp

  • Nutzer-IDs zwischen 1 und 6040.
  • Die MovieIDs reichen von 1 bis 3952.
  • Die Bewertungen werden auf einer Skala von 5 Sternen bewertet (nur Bewertungen mit ganzen Sternen).

ml-20m

Das ml-20m-Dataset enthält 20.000.263 Bewertungen von 26.744 Filmen von 138493 Nutzern. Alle Bewertungen sind in der Datei "ratings.csv" enthalten. Jede Zeile dieser Datei nach der Kopfzeile steht die Bewertung eines einzelnen Nutzers für einen Film und der folgendes Format:

userId,movieId,rating,timestamp

Die Zeilen in dieser Datei sind zuerst nach „userId“ geordnet, dann nach „user“ Film-ID angeben. Die Bewertungen werden auf einer 5-Sterne-Skala mit 0,5 bis 5,0 Sternen dargestellt. In beiden Datasets wird der Zeitstempel Sekunden seit Mitternacht, koordinierte Weltzeit (UTC) am 1. Januar 1970. Jeder Nutzer hat mindestens 20 Bewertungen.

Lernziele

  • Cloud Storage-Bucket zum Speichern der Dataset- und Modellausgabe erstellen
  • MovieLens-Dataset vorbereiten
  • Compute Engine-VM und einen Cloud TPU-Knoten für das Training und die Bewertung einrichten
  • Training und Bewertung

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweise

Bevor Sie mit dieser Anleitung beginnen, prüfen Sie, ob Ihr Google Cloud-Projekt ordnungsgemäß eingerichtet ist.

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

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

    Go to project selector

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

    Go to project selector

  5. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

    6. In dieser Anleitung werden kostenpflichtige Komponenten der Google Cloud verwendet. Rufen Sie die Seite mit den Cloud TPU-Preisen auf, um Ihre Kosten abzuschätzen. Denken Sie daran, nicht mehr benötigte Ressourcen zu bereinigen, um unnötige Kosten zu vermeiden.

Ressourcen einrichten

Dieser Abschnitt enthält Informationen zur Einrichtung von Cloud Storage-, VM- und Cloud TPU-Ressourcen für diese Anleitung.

  1. Öffnen Sie ein Cloud Shell-Fenster.

    Zu Cloud Shell

  2. Erstellen Sie eine Umgebungsvariable für die Projekt-ID.

    export PROJECT_ID=project-id

  3. Konfigurieren Sie die Google Cloud CLI für die Verwendung des Projekts, in dem Sie die Cloud TPU

    gcloud config set project ${PROJECT_ID}

    Wenn Sie diesen Befehl zum ersten Mal in einer neuen Cloud Shell-VM ausführen, wird die Seite Cloud Shell autorisieren angezeigt. Klicken Sie unten auf der Seite auf Autorisieren, damit gcloud API-Aufrufe mit Ihren Anmeldedaten ausführen kann.

  4. Erstellen Sie ein Dienstkonto für das Cloud TPU-Projekt.

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

    Der Befehl gibt ein Cloud TPU-Dienstkonto im folgenden Format zurück:

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com

  5. Erstellen Sie mit dem folgenden Befehl einen Cloud Storage-Bucket:

    gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4

    Dieser Cloud Storage-Bucket speichert die Daten, die Sie zum Trainieren Ihres Modells verwenden, sowie die Trainingsergebnisse. Mit dem gcloud-Befehl, der in dieser Anleitung zum Einrichten der TPU verwendet wird, werden auch Standardberechtigungen für das Cloud TPU-Dienstkonto eingerichtet, das Sie im vorherigen Schritt eingerichtet haben. Wenn Sie genauere Berechtigungen benötigen, können Sie die Berechtigungen auf Zugriffsebene anpassen.

    Der Bucket-Speicherort muss sich in derselben Region wie die TPU-Ressourcen befinden. TPU-VMs befinden sich in bestimmten Zonen, die Untergruppen innerhalb einer Region sind.

  6. Erstellen Sie eine Cloud TPU-VM.

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

    Beschreibung der Befehls-Flags

    zone
    Die Zone, in der Sie die Cloud TPU erstellen möchten.
    accelerator-type
    Der Beschleunigertyp gibt die Version und Größe der Cloud TPU an, die Sie erstellen möchten. Weitere Informationen zu den unterstützten Beschleunigertypen für jede TPU-Version finden Sie unter TPU-Versionen.
    version
    Die Softwareversion von Cloud TPU.

    Weitere Informationen zum Befehl gcloud finden Sie in der gcloud-Referenz.

  7. Stellen Sie über SSH eine Verbindung zur Compute Engine-Instanz her. Wenn Sie mit der VM verbunden sind, ändert sich die Shell-Eingabeaufforderung von username@projectname in username@vm-name:

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

Daten vorbereiten

  1. Fügen Sie eine Umgebungsvariable für Ihren Storage-Bucket hinzu. Ersetzen Sie bucket-name durch Ihren Bucket-Namen.

    (vm)$ export STORAGE_BUCKET=gs://bucket-name

  2. Fügen Sie eine Umgebungsvariable für das Datenverzeichnis hinzu.

    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data

  3. Modellstandort einrichten und PYTHONPATH festlegen Umgebungsvariable ein.

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

  4. Wechseln Sie zum Verzeichnis, in dem die Modellverarbeitungsdateien gespeichert sind:

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

  5. Generieren Sie Trainings- und Evaluationsdaten für das ml-20m-Dataset in 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}

Dieses Skript generiert und verarbeitet das Dataset auf Ihrer VM. Bei der Vorverarbeitung werden die Daten für das Modell in das TFRecord-Format konvertiert. Der Download und die Vorverarbeitung dauern ungefähr 25 Minuten und generieren eine Ausgabe ähnlich der folgenden:

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

Cloud TPU einrichten und Training starten

  1. Legen Sie die Cloud TPU-Namensvariable fest.

      (vm)$ export TPU_NAME=local

Training und Bewertung

Das folgende Skript führt ein Beispieltraining mit drei Epochen aus.

  1. Fügen Sie eine Umgebungsvariable für das Modellverzeichnis hinzu, um Prüfpunkte und TensorBoard-Zusammenfassungen zu speichern:

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/ncf

  2. Wenn Sie beim Erstellen der TPU den Parameter --version auf eine Version festlegen, die mit -pjrt, legen Sie die folgenden Umgebungsvariablen fest, um die PJRT-Laufzeit zu aktivieren: 

      (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so

  3. Führen Sie den folgenden Befehl aus, um das NCF-Modell zu trainieren:

    (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

Das Training und die Evaluierung dauert ungefähr zwei Minuten. Die endgültige Ausgabe sieht etwa so aus:

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

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

  1. Trennen Sie die Verbindung zur Compute Engine-Instanz, sofern noch nicht geschehen:

    (vm)$ exit

    Die Eingabeaufforderung sollte nun username@projectname lauten und angeben, dass Sie sich in Cloud Shell befinden.

  2. Löschen Sie Ihre Cloud TPU-Ressourcen.

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

  3. Prüfen Sie, ob die Ressourcen gelöscht wurden. Führen Sie dazu gcloud compute tpus tpu-vm list aus. Der Löschvorgang kann einige Minuten dauern. Eine Antwort wie die folgende gibt an, dass Ihre Instanzen erfolgreich gelöscht wurden.

      $ gcloud compute tpus tpu-vm list \
    --zone=europe-west4-a
     
    Listed 0 items.

  4. Führen Sie die gcloud CLI wie gezeigt aus und ersetzen Sie bucket-name durch Name des Cloud Storage-Bucket, den Sie für diese Anleitung erstellt haben:

    $ gcloud storage rm gs://bucket-name --recursive

Nächste Schritte

In den Cloud TPU-Anleitungen von TensorFlow wird das Modell in der Regel mithilfe eines Beispiel-Datasets trainiert. Die Ergebnisse dieses Trainings sind nicht für die Inferenz verwendbar. Wenn Sie ein Modell für die Inferenz verwenden möchten, können Sie die Daten in einem öffentlich verfügbaren Dataset oder in Ihrem eigenen Dataset trainieren. Für TensorFlow-Modelle, die auf Cloud TPUs trainiert werden, müssen Datasets im Allgemeinen das Format TFRecord haben.

Sie können das Beispiel für das Dataset-Konvertierungstool verwenden, um ein Bildklassifizierungs-Dataset in das TFRecord-Format zu konvertieren. Wenn Sie kein Bildklassifizierungsmodell verwenden, müssen Sie das Dataset selbst in das TFRecord-Format konvertieren. Weitere Informationen finden Sie unter TFRecord und tf.Example.

Hyperparameter-Feinabstimmung

Sie können die Hyperparameter des Modells optimieren, um die Leistung des Modells mit Ihrem Dataset zu verbessern. Sie finden Informationen zu allgemeinen Hyperparametern Von TPU unterstützte Modelle auf GitHub Informationen zu modellspezifischen Hyperparametern finden Sie in der Quelle Code für die einzelnen modellieren. Weitere Informationen zur Hyperparameter-Abstimmung finden Sie unter Übersicht über Hyperparameter-Abstimmung und Hyperparameter abstimmen.

Inferenz

Sobald Sie Ihr Modell trainiert haben, können Sie es für die Inferenz (auch als Vorhersage). Mit dem Cloud TPU-Inferenzkonverter können Sie ein TensorFlow-Modell für die Inferenz auf Cloud TPU v5e vorbereiten und optimieren. Weitere Informationen Informationen zur Inferenz in Cloud TPU v5e finden Sie unter Cloud TPU v5e-Inferenz .