DLRM auf Cloud TPU mit PyTorch trainieren

In dieser Anleitung wird gezeigt, wie Sie das Facebook Research DLRM auf einer Cloud TPU trainieren.

Lernziele

  • PyTorch-Umgebung erstellen und konfigurieren
  • Trainingsjob mit fiktiven Daten ausführen
  • (Optional) Mit Criteo Kaggle-Dataset trainieren

Kosten

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

  • Compute Engine
  • Cloud TPU

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.

Hinweis

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

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

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

    Zur Projektauswahl

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

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

    Zur Projektauswahl

  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.

Compute Engine-Instanz einrichten

  1. Öffnen Sie ein Cloud Shell-Fenster.

    Cloud Shell öffnen

  2. Erstellen Sie eine Variable für Ihre Projekt-ID.

    export PROJECT_ID=project-id

  3. Konfigurieren Sie die Google Cloud CLI für die Verwendung des Projekts, in dem Sie 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 mit Ihren Anmeldedaten Google Cloud API-Aufrufe ausführen kann.

  4. Starten Sie in Cloud Shell die für diese Anleitung erforderliche Compute Engine-Ressource. Hinweis: Verwenden Sie einen n1-highmem-96-machine-type für das Training mit dem Criteo Kaggle-Dataset.

    gcloud compute instances create dlrm-tutorial \
--zone=us-central1-a \
--machine-type=n1-standard-64 \
--image-family=torch-xla \
--image-project=ml-images  \
--boot-disk-size=200GB \
--scopes=https://www.googleapis.com/auth/cloud-platform

  5. Stellen Sie eine Verbindung zur neuen Compute Engine-Instanz her.

    gcloud compute ssh dlrm-tutorial --zone=us-central1-a

Cloud TPU-Ressource starten

  1. Starten Sie über die virtuelle Compute Engine-Maschine mit dem folgenden Befehl eine Cloud TPU-Ressource:

    (vm) $ gcloud compute tpus create dlrm-tutorial \
--zone=us-central1-a \
--network=default \
--version=pytorch-2.0  \
--accelerator-type=v3-8

  2. Ermitteln Sie die IP-Adresse für die Cloud TPU-Ressource.

    (vm) $ gcloud compute tpus describe dlrm-tutorial --zone=us-central1-a

PyTorch-Umgebung erstellen und konfigurieren

  1. Starten Sie eine conda-Umgebung.

    (vm) $ conda activate torch-xla-2.0

  2. Konfigurieren Sie Umgebungsvariablen für die Cloud TPU-Ressource.

    (vm) $ export TPU_IP_ADDRESS=ip-address

    (vm) $ export XRT_TPU_CONFIG="tpu_worker;0;$TPU_IP_ADDRESS:8470"

Trainingsjob mit fiktiven Daten ausführen

  1. Installieren Sie die Abhängigkeiten:

    (vm) $ pip install onnx

  2. Führen Sie das Modell mit zufälligen Daten aus. Dies dauert 5–10 Minuten.

    (vm) $ python /usr/share/torch-xla-2.0/tpu-examples/deps/dlrm/dlrm_tpu_runner.py \
    --arch-embedding-size=1000000-1000000-1000000-1000000-1000000-1000000-1000000-1000000 \
    --arch-sparse-feature-size=64 \
    --arch-mlp-bot=512-512-64 \
    --arch-mlp-top=1024-1024-1024-1 \
    --arch-interaction-op=dot \
    --lr-num-warmup-steps=10 \
    --lr-decay-start-step=10 \
    --mini-batch-size=2048 \
    --num-batches=1000 \
    --data-generation='random' \
    --numpy-rand-seed=727 \
    --print-time \
    --print-freq=100 \
    --num-indices-per-lookup=100 \
    --use-tpu \
    --num-indices-per-lookup-fixed \
    --tpu-model-parallel-group-len=8 \
    --tpu-metrics-debug \
    --tpu-cores=8

(Optional) Mit Criteo Kaggle-Dataset trainieren

Diese Schritte sind optional. Sie sollten sie nur ausführen, wenn Sie mit dem Dataset Cuteo Kaggle arbeiten möchten.

  1. Laden Sie das Dataset herunter.

    Laden Sie das Dataset aus dem Criteo Kaggle-Dataset mit dieser Anleitung herunter. Wenn der Download abgeschlossen ist, kopieren Sie die Datei dac.tar.gz in ein Verzeichnis mit dem Namen ./criteo-kaggle/. Verwenden Sie den Befehl tar -xzvf, um den Inhalt der tar.gz-Datei im Verzeichnis ./critero-kaggle zu extrahieren.

     (vm) $ mkdir criteo-kaggle
 (vm) $ cd criteo-kaggle
 (vm) $ # Download dataset from above link here.
 (vm) $ tar -xzvf dac.tar.gz
 (vm) $ cd ..

  2. Führen Sie eine Vorverarbeitung für das Dataset aus.

    Starten Sie das Skript, um das Criteo-Dataset vorzuverarbeiten. Dieses Skript erstellt eine Datei mit dem Namen kaggleAdDisplayChallenge_processed.npz. Die Vorverarbeitung des Datasets dauert mehr als drei Stunden.

    (vm) $ python /usr/share/torch-xla-2.0/tpu-examples/deps/dlrm/dlrm_data_pytorch.py \
    --data-generation=dataset \
    --data-set=kaggle \
    --raw-data-file=criteo-kaggle/train.txt \
    --mini-batch-size=128 \
    --memory-map \
    --test-mini-batch-size=16384 \
    --test-num-workers=4

  3. Prüfen Sie, ob die Vorverarbeitung erfolgreich war.

    Die Datei kaggleAdDisplayChallenge_processed.npz sollte im Verzeichnis criteo-kaggle enthalten sein.

  4. Führen Sie das Trainingsskript für ein vorverarbeitetes Criteo Kaggle-Dataset aus.

    (vm) $ python /usr/share/torch-xla-2.0/tpu-examples/deps/dlrm/dlrm_tpu_runner.py \
    --arch-sparse-feature-size=16 \
    --arch-mlp-bot="13-512-256-64-16" \
    --arch-mlp-top="512-256-1" \
    --data-generation=dataset \
    --data-set=kaggle \
    --raw-data-file=criteo-kaggle/train.txt \
    --processed-data-file=criteo-kaggle/kaggleAdDisplayChallenge_processed.npz \
    --loss-function=bce \
    --round-targets=True \
    --learning-rate=0.1 \
    --mini-batch-size=128 \
    --print-freq=1024 \
    --print-time \
    --test-mini-batch-size=16384 \
    --test-num-workers=4 \
    --memory-map \
    --test-freq=101376 \
    --use-tpu \
    --num-indices-per-lookup=1 \
    --num-indices-per-lookup-fixed \
    --tpu-model-parallel-group-len 8 \
    --tpu-metrics-debug \
    --tpu-cores=8

    Das Training sollte in 2+ Stunden mit einer Genauigkeit von mindestens 78,75 % abgeschlossen sein.

Bereinigen

Führen Sie eine Bereinigung durch, damit Ihr Konto nach der Verwendung der von Ihnen erstellten Ressourcen nicht unnötig belastet wird:

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

    (vm) $ exit

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

  2. Verwenden Sie in Cloud Shell die Google Cloud CLI, um die Compute Engine-Instanz zu löschen:

    $ gcloud compute instances delete dlrm-tutorial --zone=us-central1-a

  3. Verwenden Sie die Google Cloud CLI zum Löschen der Cloud TPU-Ressource.

    $ gcloud compute tpus delete dlrm-tutorial --zone=us-central1-a

Nächste Schritte

Testen Sie die PyTorch Colabs: