Diese Seite wurde von der Cloud Translation API übersetzt.

ShapeMask auf Cloud TPU trainieren (TF 2.x)

In diesem Dokument wird dargestellt, wie das ShapeMask-Modell mithilfe von Cloud TPU mit dem COCO-Dataset ausgeführt wird.

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

Wenn Sie auf einem TPU-Pod-Slice trainieren möchten, lesen Sie den Abschnitt Training auf TPU-Pods um für Pod-Slices erforderliche Parameteränderungen zu verstehen.

Ziele

COCO-Dataset vorbereiten
Cloud Storage-Bucket zum Speichern der Dataset- und Modellausgabe erstellen
TPU-Ressourcen für Training und Evaluierung einrichten
Training und Bewertung auf einer einzelnen Cloud TPU oder einem Cloud TPU Pod ausführen

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.

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.

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.

Cloud TPU-Training mit Einzelgerät

Dieser Abschnitt enthält Informationen zum Einrichten von Cloud Storage, VMs und Cloud TPU-Ressourcen für das Training auf einem einzelnen Gerät

Wenn Sie auf einem TPU-Pod-Slice trainieren möchten, lesen Sie den Abschnitt Training auf TPU-Pods um die Änderungen zu verstehen, die für das Training auf Pod-Slices erforderlich sind.

Erstellen Sie in Cloud Shell eine Variable für das ID.
```
export PROJECT_ID=project-id
```
Konfigurieren Sie die Google Cloud CLI für die Verwendung des Projekts, in dem Sie erstellen möchten 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 Authorize Cloud Shell angezeigt. Klicken Sie unten auf Authorize. der Seite, damit gcloud Google Cloud API-Aufrufe mit Ihrem Google Cloud-Anmeldedaten

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

COCO-Dataset vorbereiten

In dieser Anleitung wird das COCO-Dataset verwendet. Das Dataset muss im TFRecord-Format in einem Cloud Storage-Bucket vorliegen, der für das Training verwendet werden soll.

Der Bucket-Standort muss sich in derselben Region wie Ihre virtuelle Maschine (VM) befinden und Ihren TPU-Knoten. VMs und TPU-Knoten befinden sich in bestimmten Zonen, die Untergruppen innerhalb einer Region sind.

Dieser Cloud Storage-Bucket speichert die Daten, die Sie zum Trainieren Ihres Modells verwenden, sowie die Trainingsergebnisse. Mit dem gcloud compute tpus tpu-vm-Tool, das in dieser Anleitung verwendet wird, Standardberechtigungen für das Cloud TPU-Dienstkonto, das Sie im vorherigen Schritt. Wenn Sie detailliertere Berechtigungen benötigen, können Sie die Berechtigungen auf Zugriffsebene anpassen.

Wenn Sie das COCO-Dataset bereits in einem Cloud Storage-Bucket vorbereitet haben, der sich in der Zone befindet, die Sie zum Trainieren des Modells verwenden, können Sie die TPU-Ressourcen starten und die Cloud TPU für das Training vorbereiten. Andernfalls können Sie die folgenden Schritte ausführen, um sich vorzubereiten. des Datasets.

Konfigurieren Sie gcloud in Cloud Shell mit Ihrem Projekt. ID.

export PROJECT_ID=project-id
gcloud config set project ${PROJECT_ID}

Erstellen Sie in Ihrer Cloud Shell mit folgendem Befehl einen Cloud Storage-Bucket:
Hinweis: Ersetzen Sie im folgenden Befehl bucket-name durch den Namen, den Sie dem Bucket zuweisen möchten.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=us-central2
```

Erstellen Sie eine Compute Engine-VM, um das Dataset herunterzuladen und vorzuverarbeiten. Weitere Informationen finden Sie unter Compute Engine-Instanz erstellen und starten.

$ gcloud compute instances create vm-name \
    --zone=us-central2-b \
    --image-family=ubuntu-2204-lts \
    --image-project=ubuntu-os-cloud \
    --machine-type=n1-standard-16 \
    --boot-disk-size=300GB

Stellen Sie über SSH eine Verbindung zur Compute Engine-VM her:
```
$ gcloud compute ssh vm-name --zone=us-central2-b
```
Wenn Sie eine Verbindung zur VM herstellen, ändert sich die Shell-Eingabeaufforderung von username@projectname in username@vm-name.
Richten Sie zwei Variablen ein, eine für den Storage-Bucket, den Sie erstellen. und eine für das Verzeichnis, das Die Trainingsdaten (DATA_DIR) im Storage-Bucket
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```

Installieren Sie die Pakete, die für die Vorverarbeitung der Daten erforderlich sind.

(vm)$ sudo apt-get update && \
  sudo apt-get install python3-pip && \
  sudo apt-get install -y python3-tk && \
  pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow numpy absl-py tensorflow && \
  pip3 install --user "git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI"

Führen Sie das Skript download_and_preprocess_coco.sh aus, um das COCO-Dataset in einen Satz von TFRecord-Dateien (*.tfrecord) zu konvertieren, der von der Trainingsanwendung erwartet wird.
```
(vm)$ git clone https://github.com/tensorflow/tpu.git
(vm)$ sudo bash 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. Er gibt *.tfrecord-Dateien in Ihr lokales Datenverzeichnis aus. Der COCO-Download und das Ausführen des Konvertierungsskripts dauern ungefähr eine Stunde.
Kopieren Sie die Daten in Ihren Cloud Storage-Bucket.

Nachdem Sie die Daten in das TFRecord-Format konvertiert haben, kopieren Sie sie mit der gcloud CLI aus dem lokalen Speicher in Ihren Cloud Storage-Bucket. Die Anmerkungsdateien müssen ebenfalls kopiert werden. Diese Dateien helfen bei der Validierung der die Leistung.
```
(vm)$ gcloud storage cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gcloud storage cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```
Trennen Sie die Verbindung zur Compute Engine-VM:
```
(vm)$ exit
```
Die Eingabeaufforderung sollte nun username@projectname lauten und angeben, dass Sie sich in Cloud Shell befinden.

So löschen Sie Ihre Compute Engine-VM:

$ gcloud compute instances delete vm-name \
--zone=us-central2-b

TPU-Ressourcen starten und Modell trainieren

Verwenden Sie den Befehl gcloud, um die TPU-Ressourcen zu starten.
```
$ gcloud compute tpus tpu-vm create shapemask-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.

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.
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 shapemask-tutorial --zone=europe-west4-a
```
Wichtiger Punkt: Ab diesem Zeitpunkt bedeutet das Präfix (vm) $, dass Sie den Befehl in der Compute Engine-VM-Instanz ausführen sollten.

Installieren Sie TensorFlow-Anforderungen.

(vm)$ pip3 install -r /usr/share/tpu/models/official/requirements.txt

Für das Trainingsskript ist ein zusätzliches Paket erforderlich. Installieren Sie es jetzt.
```
(vm)$ pip3 install --user tensorflow-model-optimization>=0.1.3
```
Legen Sie die Variable für den Storage-Bucket-Namen fest. Ersetzen Sie bucket-name durch den Namen Ihres Storage-Buckets.
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
Legen Sie die Cloud TPU-Namensvariable fest.
```
(vm)$ export TPU_NAME=local
```

Legen Sie die Umgebungsvariable PYTHONPATH fest:

(vm)$ export PYTHONPATH="/usr/share/tpu/models:${PYTHONPATH}"

Wechseln Sie zum Verzeichnis, in dem sich das Modell befindet:
```
(vm)$ cd /usr/share/tpu/models/official/legacy/detection
```

Fügen Sie einige erforderliche Umgebungsvariablen hinzu:

(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(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 SHAPE_PRIOR_PATH=gs://cloud-tpu-checkpoints/shapemask/kmeans_class_priors_91x20x32x32.npy
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/shapemask

Wenn Sie beim Erstellen Ihrer TPU den Parameter --version auf eine Version mit der Endung -pjrt festlegen, müssen Sie die folgenden Umgebungsvariablen festlegen, 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
```

Trainieren Sie das ShapeMask-Modell:

Das folgende Skript führt ein Beispieltraining aus, das mit nur 100 Schritten trainiert wird und etwa 10 Minuten auf einer v3-8-TPU benötigt. Das Training zur Konvergenz dauert etwa 22.500 Schritte und ca. 6 Stunden auf einer v3-8-TPU.

(vm)$ python3 main.py \
  --strategy_type=tpu \
  --tpu=${TPU_NAME} \
  --model_dir=${MODEL_DIR} \
  --mode=train \
  --model=shapemask \
  --params_override="{train: {total_steps: 100, learning_rate: {init_learning_rate: 0.08, learning_rate_levels: [0.008, 0.0008], learning_rate_steps: [15000, 20000], }, checkpoint: { path: ${RESNET_CHECKPOINT},prefix: resnet50}, train_file_pattern: ${TRAIN_FILE_PATTERN}}, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}}, shapemask_parser: {output_size: [640, 640]}}"

Beschreibung der Befehls-Flags

strategy_type: Zum Trainieren des Shapemask-Modells auf einer TPU müssen Sie den Parameter distribution_strategy bis tpu.
tpu: Der Name der Cloud TPU. Dies wird mit der Umgebungsvariable TPU_NAME festgelegt.
model_dir: Das Verzeichnis, in dem während des Modelltrainings Prüfpunkte und Zusammenfassungen gespeichert werden. Wenn der Ordner fehlt, wird er vom Programm erstellt. Bei Verwendung einer Cloud TPU muss der model_dir ein Cloud Storage-Pfad (gs://...) sein. Sie können einen vorhandenen Ordner, um aktuelle Prüfpunktdaten zu laden und zu speichern, zusätzliche Prüfpunkte, sofern die vorherigen mit einer Cloud TPU derselben Größe und TensorFlow erstellt Version.
mode: Legen Sie hier train fest, um das Modell zu trainieren, oder eval, um das Modell zu bewerten.
params_override: Ein JSON-String, der Standardskriptparameter überschreibt. Weitere Informationen zu Skriptparametern finden Sie unter /usr/share/models/official/legacy/detection/main.py.

Wenn das Training abgeschlossen ist, wird eine Meldung wie diese angezeigt:

Train Step: 100/100  / loss = {'total_loss': 10.815635681152344,
'loss': 10.815635681152344, 'retinanet_cls_loss': 1.4915691614151,
'l2_regularization_loss': 4.483549118041992,
'retinanet_box_loss': 0.013074751943349838,
'shapemask_prior_loss': 0.17314358055591583,
'shapemask_coarse_mask_loss': 1.953366756439209,
'shapemask_fine_mask_loss': 2.216097831726074, 'model_loss': 6.332086086273193,
'learning_rate': 0.021359999} / training metric = {'total_loss': 10.815635681152344,
'loss': 10.815635681152344, 'retinanet_cls_loss': 1.4915691614151,
'l2_regularization_loss': 4.483549118041992,
'retinanet_box_loss': 0.013074751943349838,
'shapemask_prior_loss': 0.17314358055591583,
'shapemask_coarse_mask_loss': 1.953366756439209,
'shapemask_fine_mask_loss': 2.216097831726074,
'model_loss': 6.332086086273193, 'learning_rate': 0.021359999}

Führen Sie das Skript aus, um das ShapeMask-Modell zu bewerten. Dies dauert auf einer v3-8-TPU etwa zehn Minuten:

(vm)$ python3 main.py \
--strategy_type=tpu \
--tpu=${TPU_NAME} \
--model_dir=${MODEL_DIR} \
--checkpoint_path=${MODEL_DIR} \
--mode=eval_once \
--model=shapemask \
--params_override="{eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: 5000 }, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}}, shapemask_parser: {output_size: [640, 640]}}"

Beschreibung der Befehls-Flags

strategy_type: Zum Trainieren des Shapemask-Modells auf einer TPU müssen Sie den Parameter distribution_strategy bis tpu.
tpu: Der Name der Cloud TPU. Dies wird mit der Umgebungsvariable TPU_NAME festgelegt.
model_dir: Das Verzeichnis, in dem Prüfpunkte und Zusammenfassungen während des Modells gespeichert werden . Wenn der Ordner fehlt, wird er vom Programm erstellt. Bei Verwendung eines Cloud TPU verwenden, muss model_dir ein Cloud Storage-Pfad (gs://...). Sie können einen vorhandener Ordner, um aktuelle Prüfpunktdaten zu laden und zusätzliche Prüfpunkte, sofern die vorherigen Prüfpunkte mit einem Cloud TPU derselben Größe und TensorFlow-Version.
mode: Legen Sie hier train fest, um das Modell zu trainieren, oder eval, um das Modell zu bewerten.
params_override: Ein JSON-String, der Standardskriptparameter überschreibt. Weitere Informationen zu Skriptparametern finden Sie unter /usr/share/models/official/legacy/detection/main.py.

Sobald die Beurteilung abgeschlossen ist, wird eine Meldung wie diese angezeigt:

DONE (t=5.47s).
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000

Sie haben jetzt das Training und die Bewertung für ein einzelnes Gerät abgeschlossen. Verwenden Sie die Methode Gehen Sie so vor, um die aktuellen TPU-Ressourcen eines einzelnen Geräts zu löschen.

Trennen Sie die Verbindung zur Compute Engine-Instanz:
```
(vm)$ exit
```
Die Eingabeaufforderung sollte nun username@projectname lauten und angeben, dass Sie sich in Cloud Shell befinden.
Löschen Sie die TPU-Ressource.
```
$ gcloud compute tpus tpu-vm delete shapemask-tutorial \
    --zone=europe-west4-a
```
Beschreibung der Befehls-Flags

zone

Die Zone, in der sich Ihre Cloud TPU befindet.

An dieser Stelle können Sie entweder diese Anleitung beenden und eine Bereinigung durchführen oder die Ausführung des Modells auf Cloud TPU Pods fortsetzen.

Modell mit Cloud TPU Pods skalieren

Wenn Sie Ihr Modell auf Cloud TPU Pods trainieren möchten, müssen Sie möglicherweise einige Änderungen an Ihrem Trainingsskript vornehmen. Weitere Informationen finden Sie unter Auf TPU-Pods trainieren.

TPU-Pod-Training

Öffnen Sie ein Cloud Shell-Fenster.

Zu Cloud Shell
Erstellen Sie eine Variable für Ihre Projekt-ID.
```
export PROJECT_ID=project-id
```
Konfigurieren Sie die Google Cloud CLI für die Verwendung des Projekts, in dem Sie erstellen möchten 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 Authorize Cloud Shell angezeigt. Klicken Sie unten auf Authorize. der Seite, damit gcloud Google Cloud API-Aufrufe mit Ihrem Anmeldedaten.
Erstellen Sie ein Dienstkonto für das Cloud TPU-Projekt.

Dienstkonten ermöglichen dem Cloud TPU-Dienst, auf andere Google Cloud-Dienste zuzugreifen.
```
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 oder verwenden Sie einen vorhanden ist.

Wichtig: Richten Sie Ihre Cloud TPU-Ressourcen und Ihren Cloud Storage-Bucket in derselben Region und Zone ein, um Netzwerklatenz und Netzwerkkosten zu reduzieren. Cloud TPUs befinden sich in bestimmten Zonen, die Untergruppen innerhalb einer Region sind.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
Wenn Sie das COCO-Dataset bereits vorbereitet und in den Speicher verschoben haben Bucket für das Pod-Training nutzen. Wenn Sie sich noch nicht das COCO-Dataset, bereiten Sie es jetzt vor und kehren Sie hierher zurück, um es einzurichten. zum Pod-Training.
Cloud TPU-Pod starten

In dieser Anleitung wird ein v3-32-Pod angegeben. Weitere Pod-Optionen finden Sie unter TPU-Versionen.

Hinweis: Wenn derzeit nicht genügend Kapazität vorhanden ist, um den TPU-Pod zu erstellen, können Sie Ihre Anfrage mithilfe von Ressourcen in der Warteschlange in die Warteschlange stellen. Mit Ressourcen in der Warteschlange können Sie Kapazität empfangen, sobald diese verfügbar wird. Wenn Sie Ihre Cloud TPU-Ressourcen als Ressourcen in der Warteschlange anfordern möchten, verwenden Sie stattdessen den Befehl gcloud compute tpus queued-resources create. Weitere Informationen finden Sie unter In der Warteschlange befindliche Ressourcen verwalten.
```
$ gcloud compute tpus tpu-vm create shapemask-tutorial \
  --zone=europe-west4-a \
  --accelerator-type=v3-32 \
  --version=tpu-vm-tf-2.17.0-pod-pjrt
```
Beschreibung der Befehls-Flags

zone

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

accelerator-type

Mit dem Beschleunigertyp geben Sie die Version und Größe der Cloud TPU an, die Sie erstellen möchten. Weitere Informationen zu unterstützten Beschleunigertypen für jede TPU-Version finden Sie unter TPU-Versionen.

version

Die Softwareversion von Cloud TPU.

Hinweis: Beim erstmaligen Ausführen von gcloud für ein Projekt dauert es etwa 5 Minuten, bis alle Startprozesse wie die SSH-Schlüsselverbreitung und die API-Aktivierung abgeschlossen sind.
Hinweis: Wenn Sie mehrere Projekte haben, müssen Sie die Projekt-ID mit dem Flag --project angeben.
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 shapemask-tutorial --zone=europe-west4-a
```
Wichtiger Hinweis: Ab diesem Zeitpunkt bedeutet das Präfix (vm) $, dass Sie Führen Sie den Befehl auf der Compute Engine-VM-Instanz aus.

Installieren Sie TensorFlow-Anforderungen.

(vm)$ pip3 install -r /usr/share/tpu/models/official/requirements.txt

Für das Trainingsskript ist ein zusätzliches Paket erforderlich. Installieren Sie es jetzt.
```
(vm)$ pip3 install --user tensorflow-model-optimization>=0.1.3
```
Richten Sie die folgenden Umgebungsvariablen ein und ersetzen Sie bucket-name durch den Namen Ihres Cloud Storage-Buckets:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
Die Trainingsanwendung erwartet, dass Ihre Trainingsdaten in Cloud Storage verfügbar sind. Die Trainingsanwendung verwendet auch Ihren Cloud Storage-Bucket, um während des Trainings Prüfpunkte zu speichern.

Aktualisieren Sie die erforderlichen Trainingsvariablen.

(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/shapemask-pods
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(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 SHAPE_PRIOR_PATH=gs://cloud-tpu-checkpoints/shapemask/kmeans_class_priors_91x20x32x32.npy

Legen Sie erforderliche Umgebungsvariablen fest:

(vm)$ export PYTHONPATH="/usr/share/tpu/models:${PYTHONPATH}"
(vm)$ export TPU_LOAD_LIBRARY=0

Wechseln Sie zum Verzeichnis, in dem sich das Modell befindet:
```
(vm)$ cd /usr/share/tpu/models/official/legacy/detection
```
Starten Sie das Pod-Training.

Das Beispieltraining umfasst 20 Schritte und dauert auf einem v3-32-TPU-Knoten etwa 10 Minuten. Das Training zur Konvergenz erfordert etwa 11.250 Schritte und dauert etwa 2 Stunden auf einem v3-32-TPU-Pod.
```
(vm)$ python3 main.py \
 --strategy_type=tpu \
 --tpu=${TPU_NAME} \
 --model_dir=${MODEL_DIR} \
 --mode=train \
 --model=shapemask \
 --params_override="{train: { batch_size: 128, iterations_per_loop: 500, total_steps: 20, learning_rate: {'learning_rate_levels': [0.008, 0.0008], 'learning_rate_steps': [10000, 13000] }, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet50/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}}, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}} }"
```
Beschreibung der Befehls-Flags

strategy_type

Wenn Sie das Shapemask-Modell auf einer TPU trainieren möchten, müssen Sie distribution_strategy auf tpu festlegen.

tpu

Der Name der Cloud TPU. Dies wird mit der Umgebungsvariable TPU_NAME festgelegt.

model_dir

Das Verzeichnis, in dem Prüfpunkte und Zusammenfassungen gespeichert werden für das Modelltraining. Wenn der Ordner fehlt, wird er vom Programm erstellt. Wenn Sie eine Cloud TPU verwenden, muss model_dir ein Cloud Storage-Pfad (gs://...) sein. Sie können einen vorhandenen Ordner wiederverwenden, um aktuelle Prüfpunktdaten zu laden und zusätzliche Prüfpunkte zu speichern, solange die vorherigen Prüfpunkte mit einer Cloud TPU derselben Größe und TensorFlow-Version erstellt wurden.

mode

Legen Sie hier train fest, um das Modell zu trainieren, oder eval, um das Modell zu bewerten.

params_override

Ein JSON-String, der Standardskriptparameter überschreibt. Weitere Informationen zu Skriptparametern finden Sie unter /usr/share/models/official/legacy/detection/main.py.

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.

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

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. Die Ausgabe des folgenden Befehls sollte keine der in dieser Anleitung erstellten TPU-Ressourcen enthalten:
```
$ gcloud compute tpus tpu-vm list --zone=europe-west4-a
```
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:

Vorsicht: Wenn Sie Ihren Bucket löschen, gehen alle Trainingsdaten verloren. Führen Sie diesen Schritt also nur aus, wenn Sie die Anleitung abgeschlossen haben.
```
$ gcloud storage rm gs://bucket-name --recursive
```

Nächste Schritte

Mit verschiedenen Bildgrößen trainieren

Sie können dies mit einem größeren neuronalen Netzwerk (z. B. ResNet-101) von ResNet-50). Ein größeres Eingabebild und ein leistungsfähigeres neuronales Netzwerk ergeben ein langsameres, aber präziseres Modell.

Andere Grundlage verwenden

Alternativ können Sie ein ResNet-Modell mit Ihrem eigenen Dataset vorab trainieren und sie als Grundlage für Ihr ShapeMask-Modell zu verwenden. Mit etwas mehr Arbeit können Sie ein alternatives neuronales Netzwerk anstelle von ResNet verwenden. Wenn Sie schließlich Ihre eigenen Objekterkennungsmodelle implementieren möchten, kann eine gute Grundlage für weitere Experimente sein.