RetinaNet auf Cloud TPU trainieren (TF 2.x)

In diesem Dokument wird eine Implementierung des RetinaNet-Objekterkennungsmodells erläutert. Der Code ist auf GitHub verfügbar.

Bei der folgenden Anleitung wird davon ausgegangen, dass Sie bereits mit dem Ausführen eines Modells in 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 Auf TPU Pods trainieren, um mehr über Parameteränderungen für Pod-Slices zu erfahren.

Lernziele

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.

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.

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

Go to project selector

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

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

Go to project selector

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.

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.

Wenn Sie das COCO-Dataset bereits in einem Cloud Storage-Bucket vorbereitet haben, der sich im Zone befindet, die Sie für das Modell trainieren verwenden werden, können Sie direkt zu Training mit einem einzelnen Gerät wechseln. Führen Sie andernfalls folgende Schritte aus, um das Dataset vorzubereiten.

Öffnen Sie ein Cloud Shell-Fenster.

Cloud Shell öffnen

Konfigurieren Sie gcloud in Cloud Shell mit Ihrer 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.
```
gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 gs://bucket-name
```
Starten Sie eine Compute Engine-VM-Instanz.

Diese VM-Instanz wird ausschließlich zum Herunterladen und Vorverarbeiten des COCO-Datasets verwendet. Geben Sie in instance-name einen Namen Ihrer Wahl ein.
```
$ gcloud compute tpus execution-groups create \
 --vm-only \
 --name=instance-name \
 --zone=europe-west4-a \
 --disk-size=300 \
 --machine-type=n1-standard-16 \
 --tf-version=2.12.0
```
Beschreibung der Befehls-Flags

vm-only

Erstellen Sie nur eine VM. Standardmäßig werden mit dem Befehl gcloud compute tpus execution-groups eine VM und eine Cloud TPU erstellt.

name

Der Name der zu erstellenden Cloud TPU.

zone

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

disk-size

Die Größe der Festplatte in GB der mit dem Befehl gcloud compute tpus execution-groups erstellten VM.

machine-type

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

tf-version

Die TensorFlow-Version gcloud compute tpus execution-groups wird auf der VM installiert.
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:
```
  $ gcloud compute ssh instance-name --zone=europe-west4-a
  
```
Richten Sie zwei Variablen ein, eine für den zuvor erstellten Storage-Bucket und eine für das Verzeichnis, das die Trainingsdaten (DATA_DIR) im Storage-Bucket enthält.
```
(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 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"

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.
```
(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. Dann werden verschiedene *.tfrecord-Dateien in Ihr lokales Datenverzeichnis ausgegeben. Der COCO-Download und das Ausführen des Konvertierungsskripts dauern ungefähr eine Stunde.
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}
```
Bereinigen Sie die VM-Ressourcen.

Nachdem das COCO-Dataset in TFRecords konvertiert und in DATA_DIR in Ihrem Cloud Storage-Bucket kopiert wurde, können Sie die Compute Engine-Instanz 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 Compute Engine-Instanz.

  $ gcloud compute instances delete instance-name
    --zone=europe-west4-a

Cloud TPU-Training mit Einzelgerät

Öffnen Sie ein Cloud Shell-Fenster.

Cloud Shell öffnen
Erstellen Sie eine Variable für Ihre Projekt-ID.
```
export PROJECT_ID=project-id
```
Konfigurieren Sie die Google Cloud CLI so, dass das Projekt verwendet wird, in dem Sie eine 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, um gcloud das Ausführen von Google Cloud API-Aufrufen mit Ihren Anmeldedaten zu erlauben.

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.

Cloud TPU einrichten und starten

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 retinanet-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=retinanet-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.

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 Version von TensorFlow 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 retinanet-tutorial --zone=europe-west4-a
```
TPU-Knoten
```
gcloud compute ssh retinanet-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.

Führen Sie im weiteren Verlauf dieser Anleitung jeden Befehl, der mit (vm)$ beginnt, in Ihrem VM-Sitzungsfenster aus.

Zusätzliche Pakete installieren

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

(vm)$ sudo apt-get install -y python3-tk

(vm)$ pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow

(vm)$ pip3 install --user 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI'

Installieren Sie TensorFlow-Anforderungen.

TPU-VM

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

TPU-Knoten

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

Legen Sie die Cloud TPU-Namensvariable fest.

TPU-VM

(vm)$ export TPU_NAME=local

TPU-Knoten

(vm)$ export TPU_NAME=retinanet-tutorial

Fügen Sie Umgebungsvariablen für die Daten- und Modellverzeichnisse hinzu.

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

(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/retinanet-train

Legen Sie die Umgebungsvariable PYTHONPATH fest:

TPU-VM

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

TPU-Knoten

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

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
```

Wechseln Sie zum Verzeichnis, in dem sich das Modell befindet:

TPU-VM

(vm)$ cd /usr/share/tpu/models/official/legacy/detection

TPU-Knoten

(vm)$ cd /usr/share/models/official/legacy/detection

Einzelnes Cloud TPU-Gerät trainieren

Die folgenden Trainingsskripts wurden auf einer Cloud TPU v3-8 ausgeführt. Sie können sie auch auf einer Cloud TPU v2-8 ausführen, es dauert dann allerdings länger.

Dieses Beispielskript unten trainiert nur 10 Schritte und dauert weniger als 5 Minuten, um auf einem v3-8-TPU-Knoten ausgeführt zu werden. Das Trainieren zur Konvergenz dauert etwa 22.500 Schritte und etwa eineinhalb Stunden auf einer Cloud-TPU v3-8.

Richten Sie die folgenden Umgebungsvariablen ein:

(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

Führen Sie das Trainingsskript aus:
```
(vm)$ python3 main.py \
     --strategy_type=tpu \
     --tpu=${TPU_NAME} \
     --model_dir=${MODEL_DIR} \
     --mode="train" \
     --params_override="{ type: retinanet, train: { total_steps: 10, 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}, eval_samples: 5000 } }"
```
Beschreibung der Befehls-Flags

strategy_type

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

tpu

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

model_dir

Der Cloud Storage-Bucket, in dem während des Trainings Prüfpunkte und Zusammenfassungen gespeichert werden. Sie können einen vorhandenen Ordner verwenden, um zuvor generierte Prüfpunkte zu laden, die auf einer TPU mit derselben Größe und TensorFlow-Version erstellt wurden.

mode

Legen Sie dafür train fest, um das Modell zu trainieren, oder eval, um es 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.

Das Modell wird auf einer v3-8-TPU in zehn Schritten in etwa fünf Minuten trainiert. Nach Abschluss des Trainings sieht die Ausgabe in etwa so aus:

Train Step: 10/10  / loss = {
  'total_loss': 2.4581615924835205,
  'cls_loss': 1.4098565578460693,
  'box_loss': 0.012001709081232548,
  'model_loss': 2.0099422931671143,
  'l2_regularization_loss': 0.44821977615356445,
  'learning_rate': 0.008165999
}
/ training metric = {
  'total_loss': 2.4581615924835205,
  'cls_loss': 1.4098565578460693,
  'box_loss': 0.012001709081232548,
  'model_loss': 2.0099422931671143,
  'l2_regularization_loss': 0.44821977615356445,
 'learning_rate': 0.008165999
}

Bewertung eines einzelnen Cloud TPU-Geräts

Im folgenden Verfahren werden die COCO-Bewertungsdaten verwendet. Es dauert etwa zehn Minuten, um die Bewertungsschritte auf einer v3-8-TPU zu durchlaufen.

Richten Sie die folgenden Umgebungsvariablen ein:
```
(vm)$ export EVAL_SAMPLES=5000
```

Führen Sie das Bewertungsskript aus:

(vm)$ python3 main.py \
      --strategy_type=tpu \
      --tpu=${TPU_NAME} \
      --model_dir=${MODEL_DIR} \
      --checkpoint_path=${MODEL_DIR} \
      --mode=eval_once \
      --params_override="{ type: retinanet, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: ${EVAL_SAMPLES} } }"

Beschreibung der Befehls-Flags

strategy_type: Die zu verwendende Verteilungsstrategie. Entweder tpu oder multi_worker_gpu.
tpu: Der Name der Cloud TPU. Dieser wird mit der Umgebungsvariable TPU_NAME festgelegt.
model_dir: Der Cloud Storage-Bucket, in dem während des Trainings Prüfpunkte und Zusammenfassungen gespeichert werden. Sie können einen vorhandenen Ordner verwenden, um zuvor generierte Prüfpunkte zu laden, die auf einer TPU mit derselben Größe und TensorFlow-Version erstellt wurden.
mode: Entweder train, eval oder train_and_eval.
params_override: Ein JSON-String, der Standardskriptparameter überschreibt. Weitere Informationen zu Skriptparametern finden Sie unter /usr/share/models/official/legacy/detection/main.py.

Am Ende der Bewertung werden in der Konsole Meldungen wie die folgenden angezeigt:

Accumulating evaluation results...
DONE (t=7.66s).
 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. Führen Sie die folgenden Schritte aus, um die aktuellen Ressourcen des TPU-Einzelgerä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.
TPU-VM
```
$ gcloud compute tpus tpu-vm delete retinanet-tutorial \
--zone=europe-west4-a
```
Beschreibung der Befehls-Flags

zone

Die Zone, in der sich Ihre Cloud TPU befindet.
TPU-Knoten
```
$ gcloud compute tpus execution-groups delete retinanet-tutorial \
--tpu-only \
--zone=europe-west4-a
```
Beschreibung der Befehls-Flags

tpu-only

Löscht nur die Cloud TPU. Die VM bleibt verfügbar.

zone

Die Zone, in der die zu löschende TPU enthalten ist.

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 das Modell auf Cloud TPU-Pods trainieren, sind möglicherweise einige Änderungen am Trainingsskript erforderlich. Weitere Informationen finden Sie unter Training auf TPU-Pods.

Retinanet auf einem TPU-Pod trainieren

Öffnen Sie ein Cloud Shell-Fenster.

Cloud Shell öffnen
Erstellen Sie eine Variable für Ihre Projekt-ID.
```
export PROJECT_ID=project-id
```
Konfigurieren Sie die Google Cloud CLI so, dass das Projekt verwendet wird, in dem Sie eine 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, um gcloud das Ausführen von Google Cloud API-Aufrufen mit Ihren Anmeldedaten zu erlauben.
Erstellen Sie ein Dienstkonto für das Cloud TPU-Projekt.

Dienstkonten ermöglichen dem Cloud TPU-Dienst den Zugriff auf andere Google Cloud-Dienste.
```
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 Bucket, den Sie zuvor für Ihr Projekt erstellt haben:

Wichtig: Richten Sie die Cloud TPU-Ressourcen und den Cloud Storage-Bucket in derselben Region/Zone ein, um Netzwerklatenz und Netzwerkkosten zu reduzieren. Cloud TPUs befinden sich in bestimmten Zonen, die Untergruppen innerhalb einer Region sind.

Ersetzen Sie im folgenden Befehl europe-west4 durch den Namen der Region, die Sie zum Ausführen des Trainings verwenden möchten. Ersetzen Sie 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 in dieser Anleitung verwendeten gcloud-Befehl werden 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-Standort muss sich in derselben Region wie die TPU-Ressourcen befinden.
Wenn Sie das COCO-Dataset bereits vorbereitet und in den Storage-Bucket verschoben haben, können Sie es für das Pod-Training wiederverwenden. Wenn Sie das COCO-Dataset noch nicht vorbereitet haben, bereiten Sie es jetzt vor und kehren Sie dann hierher zurück, um das Training einzurichten.
Cloud TPU Pod einrichten und starten

In dieser Anleitung wird ein v3-32-Pod angegeben. Weitere Pod-Optionen finden Sie unter TPU-Versionen.
TPU-VM
Hinweis: Wenn derzeit nicht genügend Kapazität zum Erstellen des TPU-Pod verfügbar ist, 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 erhalten, sobald sie verfügbar ist. Verwenden Sie stattdessen den Befehl gcloud alpha compute tpus queued-resources create, um Ihre Cloud TPU-Ressourcen als Ressourcen in der Warteschlange anzufordern. Weitere Informationen finden Sie unter Ressourcen in der Warteschlange verwalten.

Starten Sie einen TPU-VM-Pod mit dem gcloud compute tpus tpu-vm-Befehl. In dieser Anleitung wird ein v3-32-Pod angegeben.
```
$ gcloud compute tpus tpu-vm create retinanet-tutorial \
--zone=europe-west4-a \
--accelerator-type=v3-32 \
--version=tpu-vm-tf-2.16.1-pod-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.

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.
TPU-Knoten
Führen Sie den Befehl gcloud compute tpus execution-groups mit dem Parameter accelerator-type aus, um das Pod-Slice anzugeben, das Sie verwenden möchten. Der folgende Befehl verwendet beispielsweise ein v3-32-Pod-Slice.
```
$ gcloud compute tpus execution-groups create  \
 --zone=europe-west4-a \
 --name=retinanet-tutorial \
 --accelerator-type=v3-32 \
 --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.

tf-version

Die TensorFlow-Version gcloud wird auf der VM installiert.
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 retinanet-tutorial --zone=europe-west4-a
```
TPU-Knoten
```
gcloud compute ssh retinanet-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.
Legen Sie die Cloud TPU-Namensvariable fest.
```
(vm)$ export TPU_NAME=retinanet-tutorial
```
Cloud Storage-Bucket-Variablen festlegen

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
```
```
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/retinanet-train
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```
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.

Zusätzliche Pakete installieren

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

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

Installieren Sie TensorFlow-Anforderungen.

TPU-VM

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

TPU-Knoten

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

Legen Sie erforderliche Umgebungsvariablen fest:

(vm)$ export RESNET_PRETRAIN_DIR=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

Legen Sie die Umgebungsvariable PYTHONPATH fest:

TPU-VM

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

TPU-Knoten

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

Wechseln Sie zum Verzeichnis, in dem sich das Modell befindet:

TPU-VM

(vm)$ cd /usr/share/tpu/models/official/legacy/detection

TPU-Knoten

(vm)$ cd /usr/share/models/official/legacy/detection

Modell trainieren
TPU-VM
```
(vm)$ python3 main.py \
--strategy_type=tpu \
--tpu=${TPU_NAME} \
--model_dir=${MODEL_DIR} \
--mode=train \
--model=retinanet \
--params_override="{architecture: {use_bfloat16: true}, eval: {batch_size: 40, eval_file_pattern: ${EVAL_FILE_PATTERN}, val_json_file: ${VAL_JSON_FILE}}, postprocess: {pre_nms_num_boxes: 1000}, predict: {batch_size: 40}, train: {batch_size: 256, checkpoint: {path: ${RESNET_PRETRAIN_DIR}, prefix: resnet50/}, iterations_per_loop: 5000, total_steps: 5625, train_file_pattern: ${TRAIN_FILE_PATTERN}, } }" 
```
Beschreibung der Befehls-Flags

tpu

Der Name Ihrer TPU.

model_dir

Gibt das Verzeichnis an, in dem während des Modelltrainings Prüfpunkte und Zusammenfassungen gespeichert werden. Wenn der Ordner fehlt, erstellt das Programm einen. 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 Cloud TPU derselben Größe und TensorFlow-Version erstellt wurden.

params_override

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

Mit diesem Verfahren wird das Modell für das COCO-Dataset für 5625 Trainingsschritte trainiert. Dieses Training dauert bei einer v3-32 Cloud TPU etwa 20 Minuten. Wenn das Training abgeschlossen ist, wird eine Meldung wie diese angezeigt:
TPU-Knoten

Das folgende Beispieltrainingsskript wurde auf einem Cloud TPU-v3-32-Pod ausgeführt. Dieses trainiert nur 10 Schritte und dauert weniger als 5 Minuten. Das Training zur Konvergenz erfordert 2.109 Schritte und dauert auf einem v3-32-TPU-Pod etwa 50 Minuten.
```
(vm)$  python3 main.py \
--strategy_type=tpu \
--tpu=${TPU_NAME} \
--model_dir=${MODEL_DIR} \
--mode="train" \
--params_override="{ type: retinanet, train: { total_steps: 10, batch_size: 256, 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}, eval_samples: 5000 } }" 
```
Beschreibung der Befehls-Flags

strategy_type

Die zu verwendende Verteilungsstrategie. tpu oder multi_worker_gpu.

tpu

Gibt den Namen der Cloud TPU an. Dieser wird mit der Umgebungsvariable TPU_NAME festgelegt.

model_dir

Der Cloud Storage-Bucket, in dem während des Trainings Prüfpunkte und Zusammenfassungen gespeichert werden. Sie können einen vorhandenen Ordner verwenden, um zuvor generierte Prüfpunkte zu laden, die auf einer TPU mit derselben Größe und TensorFlow-Version erstellt wurden.

mode

Entweder train, eval oder train_and_eval.

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:

TPU-VM

Train Step: 5625/5625  / loss = {'total_loss': 0.730501651763916,
'cls_loss': 0.3229793608188629, 'box_loss': 0.003082591574639082,
'model_loss': 0.4771089553833008, 'l2_regularization_loss': 0.2533927261829376,
'learning_rate': 0.08} / training metric = {'total_loss': 0.730501651763916,
'cls_loss': 0.3229793608188629, 'box_loss': 0.003082591574639082,
'model_loss': 0.4771089553833008, 'l2_regularization_loss': 0.2533927261829376,
'learning_rate': 0.08}

TPU-Knoten

Train Step: 10/10  / loss = {'total_loss': 3.5455241203308105,
'cls_loss': 1.458828330039978, 'box_loss': 0.01220895815640688,
'model_loss': 2.0692763328552246, 'l2_regularization_loss': 1.4762479066848755,
'learning_rate': 0.008165999} / training metric = {'total_loss': 3.5455241203308105,
'cls_loss': 1.458828330039978, 'box_loss': 0.01220895815640688,
'model_loss': 2.0692763328552246, 'l2_regularization_loss': 1.4762479066848755,
'learning_rate': 0.008165999}

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-VM:
```
(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 retinanet-tutorial \
--zone=europe-west4-a
```
TPU-Knoten
```
$ gcloud compute tpus execution-groups delete retinanet-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.
```
$ gcloud compute tpus execution-groups list --zone=europe-west4-a
```
```
Listed 0 items.
```
Löschen Sie Ihren Cloud Storage-Bucket wie unten gezeigt mit gsutil. Ersetzen Sie bucket-name durch den Namen des Cloud Storage-Buckets.
```
$ 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.

Mit verschiedenen Bildgrößen trainieren

Sie können auch ein größeres Backbonenetzwerk wie ResNet-101 statt ResNet-50 ausprobieren. Ein größeres Eingabebild und ein leistungsfähigeres Backbonenetzwerk ergeben ein langsameres, aber präziseres Modell.

Andere Grundlage verwenden

Alternativ können Sie versuchen, ein ResNet-Modell im Voraus mit Ihrem eigenen Dataset zu trainieren und es als Grundlage für Ihr RetinaNet-Modell zu verwenden. Sie haben auch die Möglichkeit, ResNet durch ein alternatives Backbonenetzwerk zu ersetzen, was etwas arbeitsaufwändiger ist. Wenn Sie Ihre eigenen Objekterkennungsmodelle implementieren möchten, ist dieses Netzwerk möglicherweise eine gute Basis für weitere Experimente.