Mask RCNN in Cloud TPU trainieren

Übersicht

In dieser Anleitung wird erläutert, wie Sie das Mask RCNN-Modell mit Cloud TPU mit dem COCO-Dataset ausführen.

Mask RCNN ist ein neuronales Deep-Learning-Netzwerk, das für die Objekterkennung und Bildsegmentierung entwickelt wurde, eine der komplexeren Herausforderungen beim maschinellen Sehen.

Das Mask RCNN-Modell generiert Begrenzungsrahmen und Segmentierungsmasken für jede Instanz eines Objekts im Bild. Das Modell basiert auf dem Feature Pyramid Network (FPN) und einem ResNet50 neuronales Netzwerk.

In dieser Anleitung wird das Modell mit tf.contrib.tpu.TPUEstimator trainiert. Die TPUEstimator API ist eine übergeordnete TensorFlow API und die empfohlene Methode zum Erstellen und Ausführen eines Modells für maschinelles Lernen auf Cloud TPU. Die API vereinfacht den Modellentwicklungsprozess. Sie blendet die meisten Implementierungen auf untergeordneter Ebene aus, wodurch leichter zwischen der TPU und anderen Plattformen wie GPUs oder CPUs gewechselt werden kann.

Ziele

Cloud Storage-Bucket zum Speichern der Dataset- und Modellausgabe erstellen
COCO-Dataset vorbereiten
Compute Engine-VM und einen Cloud TPU-Knoten für das Training und die Bewertung einrichten
Training und Bewertung auf einer einzelnen Cloud TPU oder einem Cloud TPU Pod ausführen

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

Compute Engine
Cloud TPU
Cloud Storage

Sie können mithilfe des Preisrechners die Kosten für Ihre voraussichtliche Nutzung kalkulieren. 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-Konto an.
Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

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

Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

Zur Projektauswahl

Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

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.

Wenn Sie auf einem TPU Pod-Slice trainieren möchten, lesen Sie Auf TPU Pods trainieren, um mehr über Parameteränderungen für Pod-Slices zu erfahren.

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.

Zu Cloud Shell
Erstellen Sie eine Umgebungsvariable für die Projekt-ID.
```
export PROJECT_ID=project-id
```
Konfigurieren Sie das gcloud - Befehlszeilentool für die Verwendung des Projekts, 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 auf Authorize unten auf der Seite, um es gcloud zu erlauben, GCP API-Aufrufe mit Ihren Anmeldedaten durchzuführen.

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 -b on gs://bucket-name
```
Dieser Cloud Storage-Bucket speichert die Daten, die Sie zum Trainieren Ihres Modells verwenden, und die Trainingsergebnisse. Das in dieser Anleitung verwendete Tool ctpu up richtet Standardberechtigungen für das Cloud TPU-Dienstkonto ein. Wenn Sie weitere 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 ctpu up eine Compute Engine-VM.

Hinweis: In dieser Anleitung wird TensorFlow 1.15.5 verwendet, das auf dem Debian 10-Image basiert und standardmäßig Python 3.6 verwendet. Frühere Versionen von TensorFlow 1.15.x basieren auf Debian 9 und entsprechen standardmäßig Python 3.5.
```
(vm)$ ctpu up --project=${PROJECT_ID} \
 --zone=europe-west4-a \
 --vm-only \
 --disk-size-gb=300 \
 --machine-type=n1-standard-8 \
 --tf-version=1.15.5 \
 --name=mask-rcnn-tutorial
```
Beschreibung der Befehls-Flags

project

Die ID Ihres GCP-Projekts

zone
Die Zone, in der Sie die Cloud TPU erstellen möchten.
vm-only

Erstellt die VM ohne Cloud TPU. Standardmäßig werden mit dem Befehl ctpu up eine VM und eine Cloud TPU erstellt.

disk-size-gb
Die Größe des Laufwerks in GB der VM, die mit dem Befehl ctpu up erstellt wurde.
machine-type
Der Maschinentyp der zu erstellenden Compute Engine-VM.
tf-version
Die Version von Tensorflow, die von ctpu auf der VM installiert wird.
name
Der Name der zu erstellenden Cloud TPU.
Die von Ihnen angegebene Konfiguration wird angezeigt. Geben Sie y zum Bestätigen oder n zum Abbrechen ein.
Wenn der Befehl ctpu up ausgeführt wurde, sollten Sie prüfen, ob die Shell-Eingabeaufforderung von username@projectname in username@vm-name geändert wurde. Diese Änderung bedeutet, dass Sie jetzt bei Ihrer Compute Engine-VM angemeldet sind.

Hinweis: Beim erstmaligen Ausführen von ctpu up für ein Projekt dauert es einige Minuten, bis alle Startprozesse wie die SSH-Schlüsselweitergabe und die API-Aktivierung abgeschlossen sind. Manchmal wird bei der SSH-Schlüsselweitergabe eine Fehlermeldung (ERROR: (gcloud.compute.ssh) [/usr/bin/ssh] exited with return code [255]) zurückgegeben. Führen Sie in diesem Fall den folgenden Befehl aus, um das Problem zu beheben.
```
gcloud compute ssh mask-rcnn-tutorial --zone=europe-west4-a
```
Führen Sie im weiteren Verlauf dieser Anleitung jeden Befehl, der mit (vm)$ beginnt, in Ihrem VM-Sitzungsfenster aus.

Zusätzliche Pakete installieren

Die Mask RCNN-Trainingsanwendung erfordert mehrere zusätzliche Pakete. Installieren Sie diese jetzt:

(vm)$ sudo apt-get install -y python3-tk && \
  pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow && \
  pip3 install --user 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI' && \
  pip3 install --user -U gast==0.2.2

Keepalive-Werte der VM-Verbindung aktualisieren

Diese Anleitung erfordert eine langlebige Verbindung zur Compute Engine-Instanz. Führen Sie den folgenden Befehl aus, um zu prüfen, ob eine Verbindung zur Instanz besteht:

(vm)$ sudo /sbin/sysctl \
  -w net.ipv4.tcp_keepalive_time=120 \
  net.ipv4.tcp_keepalive_intvl=120 \
  net.ipv4.tcp_keepalive_probes=5

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}/coco
```
Fügen Sie eine Umgebungsvariable für das Modellverzeichnis hinzu.
```
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mask-rcnn
```
Führen Sie das Skript download_and_preprocess_coco.sh aus, um das COCO-Dataset in einen Satz von TFRecords (*.tfrecord) zu konvertieren, der von der Trainingsanwendung erwartet wird.

Hinwesi: Der COCO-Download und das Ausführen des Konvertierungsskripts dauern ungefähr eine Stunde.
```
(vm)$ sudo bash /usr/share/tpu/tools/datasets/download_and_preprocess_coco.sh ./data/dir/coco
```
Dadurch werden die erforderlichen Bibliotheken installiert und das Skript für die Vorverarbeitung ausgeführt. Dann werden verschiedene *.tfrecord-Dateien in Ihr lokales Datenverzeichnis ausgegeben.
Daten in den Cloud Storage-Bucket kopieren

Nachdem Sie die Daten in TFRecords konvertiert haben, kopieren Sie sie mit dem Befehl gsutil aus dem lokalen Speicher in den Cloud Storage-Bucket. Die Annotationsdateien müssen ebenfalls kopiert werden. Diese Dateien helfen dabei, die Leistung des Modells zu validieren.
```
(vm)$ gsutil -m cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
```
```
(vm)$ gsutil cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```

Cloud TPU einrichten und starten

Führen Sie den folgenden Befehl aus, um die Cloud TPU zu erstellen.
```
(vm)$ ctpu up --project=${PROJECT_ID} \
  --tpu-only \
  --tpu-size=v3-8 \
  --zone=europe-west4-a \
  --name=mask-rcnn-tutorial \
  --tf-version=1.15.5
```
Beschreibung der Befehls-Flags

project

Die ID Ihres GCP-Projekts

tpu-only

Erstellen Sie nur eine Cloud TPU. Standardmäßig werden mit dem Befehl ctpu up eine VM und eine Cloud TPU erstellt.

zone
Die Zone, in der Sie die Cloud TPU erstellen möchten.
name
Der Name der zu erstellenden Cloud TPU.
tf-version
Die Version von Tensorflow, die von ctpu auf der VM installiert wird.
Die von Ihnen angegebene Konfiguration wird angezeigt. Geben Sie y zum Bestätigen oder n zum Abbrechen ein.

Sie erhalten folgende Meldung: Operation success; not ssh-ing to Compute Engine VM due to --tpu-only flag. Da Sie die SSH-Schlüsselverteilung bereits abgeschlossen haben, können Sie diese Nachricht ignorieren.
Fügen Sie eine Umgebungsvariable für den Namen Ihrer Cloud TPU hinzu.
```
(vm)$ export TPU_NAME=mask-rcnn-tutorial
```

Training und Bewertung

Fügen Sie einige erforderliche Umgebungsvariablen hinzu:

(vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/tpu/models"
(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
(vm)$ export TRAIN_FILE_PATTERN=${DATA_DIR}/train-*
(vm)$ export EVAL_FILE_PATTERN=${DATA_DIR}/val-*
(vm)$ export VAL_JSON_FILE=${DATA_DIR}/instances_val2017.json
(vm)$ export ACCELERATOR_TYPE=v3-8

Rufen Sie das Verzeichnis /usr/share auf.
```
(vm)$ cd /usr/share
```

Führen Sie für das Training und die Bewertung den folgenden Befehl aus.

(vm)$ python3 tpu/models/official/mask_rcnn/mask_rcnn_main.py \
--use_tpu=True \
--tpu=${TPU_NAME} \
--model_dir=${MODEL_DIR} \
--num_cores=8 \
--mode="train_and_eval" \
--config_file="/usr/share/tpu/models/official/mask_rcnn/configs/cloud/${ACCELERATOR_TYPE}.yaml" \
--params_override="checkpoint=${RESNET_CHECKPOINT}, training_file_pattern=${TRAIN_FILE_PATTERN}, validation_file_pattern=${EVAL_FILE_PATTERN}, val_json_file=${VAL_JSON_FILE}"

Von hier aus können Sie entweder diese Anleitung abschließen und Ihre GCP-Ressourcen bereinigen oder sich die Ausführung des Modells auf einem Cloud TPU Pod genauer ansehen.

Modell mit Cloud TPU Pods skalieren

Wenn Sie ein Modell mit Cloud TPU Pods skalieren, können Sie schneller Ergebnisse erzielen. Das vollständig unterstützte Mask RCNN-Modell funktioniert mit den folgenden Pod-Slices:

v2-32
v3-32

Wenn Sie Cloud TPU Pods verwenden, trainieren Sie zuerst das Modell mit einem Pod und verwenden dann ein einzelnes Cloud TPU-Gerät, um das Modell zu bewerten.

Cloud TPU Pods trainieren

Wenn Sie Ihre Compute Engine-Instanz bereits gelöscht haben, erstellen Sie gemäß den Schritten unter Ressourcen einrichten eine neue Instanz.

Löschen Sie die Cloud TPU-Ressource, die Sie zum Trainieren des Modells auf einem einzelnen Cloud TPU-Gerät erstellt haben.
```
(vm)$ ctpu delete --project=${PROJECT_ID} \
 --tpu-only \
 --zone=europe-west4-a \
 --name=mask-rcnn-tutorial
```
Führen Sie den Befehl ctpu up mit dem Parameter tpu-size aus, um das Pod-Slice anzugeben, das Sie verwenden möchten. Der folgende Befehl verwendet beispielsweise einen v3-32-Pod-Slice.
```
(vm)$ ctpu up --project=${PROJECT_ID} \
  --tpu-only \
  --tpu-size=v3-32 \
  --zone=europe-west4-a \
  --name=mask-rcnn-pods \
  --tf-version=1.15.5
```

Aktualisieren Sie die Umgebungsvariablen TPU_NAME, MODEL_DIR und Accelerator_TYPE.

(vm)$ export TPU_NAME=mask-rcnn-pods
(vm)$ export ACCELERATOR_TYPE=v3-32
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mask-rcnn-pods

Starten Sie das Trainingsskript.

(vm)$ python3 tpu/models/official/mask_rcnn/mask_rcnn_main.py \
  --use_tpu=True \
  --tpu=${TPU_NAME} \
  --iterations_per_loop=500 \
  --model_dir=${MODEL_DIR} \
  --num_cores=32 \
  --mode="train" \
  --config_file="/usr/share/tpu/models/official/mask_rcnn/configs/cloud/${ACCELERATOR_TYPE}.yaml" \
  --params_override="checkpoint=${RESNET_CHECKPOINT}, training_file_pattern=${TRAIN_FILE_PATTERN}, validation_file_pattern=${EVAL_FILE_PATTERN}, val_json_file=${VAL_JSON_FILE}"

Modell bewerten

In diesem Schritt verwenden Sie einen einzelnen Cloud TPU-Knoten, um das oben trainierte Modell mit dem COCO-Dataset zu bewerten. Dies dauert etwa 10 Minuten.

Löschen Sie die Cloud TPU-Ressource, die Sie zum Trainieren des Modells auf einem Pod erstellt haben.

(vm)$ ctpu delete --project=${PROJECT_ID} \
 --tpu-only \
 --zone=europe-west4-a \
 --name=${TPU_NAME}

Starten Sie ein neues TPU-Gerät, um die Bewertung auszuführen.

(vm)$ ctpu up --project=${PROJECT_ID} \
  --tpu-only \
  --tpu-size=v3-8 \
  --zone=europe-west4-a \
  --name=mask-rcnn-eval \
  --tf-version=1.15.5

Aktualisieren Sie die Umgebungsvariable TPU_NAME.
```
(vm)$ export TPU_NAME=mask-rcnn-eval
```

Starten Sie die Bewertung.

(vm)$ python3 tpu/models/official/mask_rcnn/mask_rcnn_main.py \
  --use_tpu=True \
  --tpu=${TPU_NAME} \
  --iterations_per_loop=500 \
  --mode=eval \
  --model_dir=${MODEL_DIR} \
  --config_file="/usr/share/tpu/models/official/mask_rcnn/configs/cloud/${ACCELERATOR_TYPE}.yaml" \
  --params_override="checkpoint=${CHECKPOINT},training_file_pattern=${PATH_GCS_MASKRCNN}/train-*,val_json_file=${PATH_GCS_MASKRCNN}/instances_val2017.json,validation_file_pattern=${PATH_GCS_MASKRCNN}/val-*,init_learning_rate=0.28,learning_rate_levels=[0.028, 0.0028, 0.00028],learning_rate_steps=[6000, 8000, 10000],momentum=0.95,num_batch_norm_group=1,num_steps_per_eval=500,global_gradient_clip_ratio=0.02,total_steps=11250,train_batch_size=512,warmup_steps=1864"

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.

Bereinigen Sie die Compute Engine-VM-Instanz und die Cloud TPU-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.
Führen Sie in Cloud Shell den Befehl ctpu delete mit dem Flag "--zone" aus, das Sie auch beim Einrichten der Cloud TPU angegeben haben, um die Compute Engine-VM und die Cloud TPU zu löschen:
```
$ ctpu delete --project=${PROJECT_ID} \
  --name=mask-rcnn-tutorial \
  --zone=europe-west4-a
```
Wichtig: Wenn Sie den TPU-Ressourcennamen bei der Ausführung von ctpu up festgelegt haben, müssen Sie diesen Namen beim Ausführen von ctpu delete mit dem Flag --name angeben, um die TPU-Ressourcen herunterzufahren.
Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Compute Engine-VM und die Cloud TPU heruntergefahren wurden:
```
$ ctpu status --project=${PROJECT_ID} \
  --zone=europe-west4-a
```
Der Löschvorgang kann einige Minuten dauern. Eine Antwort wie die folgende gibt an, dass keine weiteren Instanzen vorhanden sind:
```
2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
No instances currently exist.
        Compute Engine VM:     --
        Cloud TPU:             --
```
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 dieser Anleitung haben Sie das Mask-RCNN-Modell mit einem Beispiel-Dataset trainiert. Die Ergebnisse dieses Trainings sind in den meisten Fällen 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 Modelle, die auf Cloud TPUs trainiert wurden, müssen Datasets 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 TFRecords-Format konvertieren. Weitere Informationen finden Sie unter TFRecord und tf.Example

Hyperparameter-Abstimmung

Sie können die Hyperparameter des Modells optimieren, um die Leistung des Modells mit Ihrem Dataset zu verbessern. Informationen zu Hyperparametern, die für alle TPU-unterstützten Modelle üblich sind, finden Sie auf GitHub. Informationen zu modellspezifischen Hyperparametern finden Sie im Quellcode für die einzelnen Modelle. Weitere Informationen zur Hyperparameter-Abstimmung finden Sie unter Übersicht über Hyperparameter-Abstimmung, Hyperparameter-Abstimmungsdienst und Hyperparameter abstimmen.

Inferenz

Sobald Ihr Modell trainiert ist, können Sie es für Inferenz (auch als Vorhersage bezeichnet) verwenden. AI Platform ist eine cloudbasierte Lösung, mit der Sie Modelle für maschinelles Lernen entwickeln, trainieren und bereitstellen können. Sobald ein Modell bereitgestellt wurde, können Sie den AI Platform Prediction-Dienst verwenden.

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