NCF auf Cloud TPU trainieren (TF 2.x)

Überblick

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 aus dem NCF-Code des Autors und der Stanford-Implementierung im MLPerf Repository.

NCF ist ein allgemeines Framework für die kollaborative Filterung von Empfehlungen, in der Interaktionen mit Nutzerobjekten durch neuronale Netzwerkarchitektur modelliert werden. Anders als bei herkömmlichen Modellen ist beim NCF die Umwandlung in die Matrixfaktorisierung (MF) mit einem inneren Produkt zu einem Late-Feature von Nutzern und Elementen nicht möglich. Es 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 NewFM 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.

Bei der folgenden Anleitung wird davon ausgegangen, dass Sie bereits mit dem Training eines Modells in Cloud TPU vertraut sind. Wenn Sie Cloud TPU noch nicht kennen, finden Sie in der Kurzanleitung eine grundlegende Einführung.

Dataset

Die MovieLens-Datasets werden für das Modelltraining und die Bewertung verwendet. Insbesondere verwenden wir 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 ungefähr 3.706 Filmen von 6.40 Nutzern, die im Jahr 2000 MovieLens beigetreten sind. 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 stellt die Bewertung eines Films durch einen einzelnen Nutzer im folgenden Format dar:

userId,movieId,rating,timestamp

Die Zeilen in dieser Datei werden zuerst nach der Nutzer-ID, dann innerhalb des Nutzers nach movieId sortiert. Die Bewertungen werden auf einer 5-Sterne-Skala mit 50 bis 0,5 Sternen dargestellt. In beiden Datasets wird der Zeitstempel in Sekunden seit Mitternacht der koordinierten Weltzeit (UTC) vom 1. Januar 1970 dargestellt. 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.

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

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

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

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

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.

Öffnen Sie ein Cloud Shell-Fenster.

Cloud Shell öffnen
Erstellen Sie eine Umgebungsvariable für die Projekt-ID.
```
export PROJECT_ID=project-id
```
Konfigurieren Sie die Google Cloud CLI so, dass das Projekt verwendet wird, in dem Sie die Cloud TPU erstellen möchten.
```
gcloud config set project ${PROJECT_ID}
```
Wenn Sie diesen Befehl zum ersten Mal in einer neuen Cloud Shell-VM ausführen, wird die Seite Authorize Cloud Shell angezeigt. Klicken Sie unten auf der Seite auf Authorize, damit gcloud API-Aufrufe mit Ihren Anmeldedaten ausführen kann.

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

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

Hinweis: Ersetzen Sie im folgenden Befehl bucket-name durch den Namen, den Sie dem Bucket zuweisen möchten.
```
gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 gs://bucket-name
```
Dieser Cloud Storage-Bucket speichert die Daten, die Sie zum Trainieren Ihres Modells verwenden, und 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 detailliertere Berechtigungen benötigen, können Sie die Berechtigungen auf Zugriffsebene anpassen.

Der Bucket-Speicherort muss sich in derselben Region wie die virtuelle Maschine (VM) und der TPU-Knoten befinden. VMs und TPU-Knoten befinden sich in bestimmten Zonen, die Untergruppen innerhalb einer Region sind.
Starten Sie mit dem Befehl gcloud eine Compute Engine-VM und eine Cloud TPU. Der verwendete Befehl hängt davon ab, ob Sie TPU-VMs oder TPU-Knoten verwenden. Weitere Informationen zu beiden VM-Architekturen finden Sie unter Systemarchitektur.
TPU-VM
```
$ gcloud compute tpus tpu-vm create ncf-tutorial \
--zone=europe-west4-a \
--accelerator-type=v3-8 \
--version=tpu-vm-tf-2.16.1-pjrt
```
Beschreibung der Befehls-Flags

zone

Die Zone, in der Sie Ihre 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 unterstützten Beschleunigertypen für die einzelnen TPU-Versionen finden Sie unter TPU-Versionen.

version

Die Cloud TPU-Softwareversion.
TPU-Knoten
```
$ 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.12.0
```
Beschreibung der Befehls-Flags

zone

Die Zone, in der Sie Ihre Cloud TPU erstellen möchten.

name

Der TPU-Name. Ist standardmäßig Ihr Nutzername, wenn nichts anderes angegeben ist.

accelerator-type

Der Typ der zu erstellenden Cloud TPU.

machine-type

Der Maschinentyp der Compute Engine-VM, die erstellt werden soll.

disk-size

Die Größe des Stamm-Volumes Ihrer Compute Engine-VM (in GB).

tf-version

Die TensorFlow-Version gcloud wird auf der VM installiert.
Hinweis: Wenn Sie mehrere Projekte haben, müssen Sie die Projekt-ID mit dem Flag --project angeben.

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

Hinweis: Beim erstmaligen Ausführen von gcloud compute tpus für ein Projekt dauert es etwa 5 Minuten, bis alle Startprozesse wie die SSH-Schlüsselverbreitung und die API-Aktivierung abgeschlossen sind.
Wenn Sie nicht automatisch bei der Compute Engine-Instanz angemeldet werden, melden Sie sich mit dem folgenden ssh-Befehl an. Wenn Sie bei der VM angemeldet sind, ändert sich die Shell-Eingabeaufforderung von username@projectname in username@vm-name:
TPU-VM
```
gcloud compute tpus tpu-vm ssh ncf-tutorial --zone=europe-west4-a
```
TPU-Knoten
```
gcloud compute ssh ncf-tutorial --zone=europe-west4-a
```
Wichtiger Hinweis: Ab jetzt bedeutet das Präfix (vm)$, dass Sie den Befehl in der Compute Engine-VM-Instanz ausführen sollten.

Daten vorbereiten

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
```
Fügen Sie eine Umgebungsvariable für das Datenverzeichnis hinzu.
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
```

Richten Sie den Modellspeicherort ein und legen Sie die Umgebungsvariable PYTHONPATH fest.

TPU-VM

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

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

TPU-Knoten

(vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
(vm)$ pip3 install -r /usr/share/models/official/requirements.txt

Wechseln Sie zum Verzeichnis, in dem die Modellverarbeitungsdateien gespeichert sind:
TPU-VM
```
(vm)$ cd ~/models/official/recommendation
```
TPU-Knoten
```
(vm)$ cd /usr/share/models/official/recommendation
```
Generieren Sie Trainings- und Evaluationsdaten für das ml-20m-Dataset in DATA_DIR:

Hinweis: Es empfiehlt sich, dem Downloadbefehl nohup voranzustellen oder screen zu verwenden, damit der Download nicht beendet wird, wenn die Verbindung zu Cloud Shell getrennt wird.
```
(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

Legen Sie die Cloud TPU-Namensvariable fest.

TPU-VM

(vm)$ export TPU_NAME=local

TPU-Knoten

(vm)$ export TPU_NAME=ncf-tutorial

Training und Bewertung

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

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
```
Wenn Sie beim Erstellen Ihrer TPU den Parameter --version auf eine Version festlegen, die auf -pjrt endet, 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
```

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.

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.
Löschen Sie Ihre Cloud TPU- und Compute Engine-Ressourcen. Der Befehl zum Löschen Ihrer Ressourcen hängt davon ab, ob Sie TPU-VMs oder TPU-Knoten verwenden. Weitere Informationen finden Sie unter Systemarchitektur.
TPU-VM
```
$ gcloud compute tpus tpu-vm delete ncf-tutorial \
--zone=europe-west4-a
```
TPU-Knoten
```
$ gcloud compute tpus execution-groups delete ncf-tutorial \
--zone=europe-west4-a
```
Prüfen Sie, ob die Ressourcen gelöscht wurden. Führen Sie dazu gcloud compute tpus execution-groups list aus. Der Löschvorgang kann einige Minuten dauern. Eine Antwort wie die folgende gibt an, dass Ihre Instanzen erfolgreich gelöscht wurden.
TPU-VM
```
$ gcloud compute tpus tpu-vm list \
--zone=europe-west4-a
```
TPU-Knoten
```
$ gcloud compute tpus execution-groups list --zone=europe-west4-a
```
```
Listed 0 items.
```
Führen Sie gsutil wie angegeben aus und ersetzen Sie dabei bucket-name durch den Namen des Cloud Storage-Buckets, den Sie für diese Anleitung erstellt haben:
```
$ gsutil rm -r gs://bucket-name
```

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 Inferenzen verwendbar. Wenn Sie ein Modell für die Inferenz verwenden möchten, können Sie die Daten mit einem öffentlich verfügbaren Dataset oder Ihrem eigenen Dataset trainieren. Für TensorFlow-Modelle, die auf Cloud TPUs trainiert wurden, müssen im Allgemeinen Datasets im TFRecord-Format erforderlich sein.

Mit dem Beispiel für das Dataset-Konvertierungstool können Sie ein Bildklassifizierungs-Dataset in das TFRecord-Format 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 abstimmen, um die Leistung des Modells mit Ihrem Dataset zu verbessern. Informationen zu den Hyperparametern, die alle von der TPU unterstützten Modelle gemeinsam sind, finden Sie auf GitHub. Informationen zu modellspezifischen Hyperparametern finden Sie im Quellcode des jeweiligen Modells. Weitere Informationen zur Abstimmung von Hyperparametern finden Sie unter Übersicht über die Abstimmung von Hyperparametern und Hyperparameter abstimmen.

Inferenz

Nachdem Sie Ihr Modell trainiert haben, können Sie es für Inferenzen (auch Vorhersage genannt) verwenden. Mit dem Cloud TPU-Inferenzkonverter-Tool können Sie ein TensorFlow-Modell für die Inferenz in Cloud TPU v5e vorbereiten und optimieren. Weitere Informationen zur Inferenz in Cloud TPU v5e finden Sie unter Einführung in Cloud TPU v5e-Inferenz.

Mehr über ctpu und die Installation auf einem lokalen Computer
TPU-Tools in TensorBoard

NCF auf Cloud TPU trainieren (TF 2.x)

Überblick

Dataset

ml-1m

ml-20m

Lernziele

Kosten

Hinweise

Ressourcen einrichten

TPU-VM

Beschreibung der Befehls-Flags

TPU-Knoten

Beschreibung der Befehls-Flags

TPU-VM

TPU-Knoten

Daten vorbereiten

TPU-VM

TPU-Knoten

TPU-VM

TPU-Knoten

Cloud TPU einrichten und Training starten

TPU-VM

TPU-Knoten

Training und Bewertung

Bereinigen

TPU-VM

TPU-Knoten

TPU-VM

TPU-Knoten

Nächste Schritte

Hyperparameter-Feinabstimmung

Inferenz