Pomoc chronić Wielkiej Rafy Koralowej z TensorFlow na Kaggle Dołącz Wyzwanie

Trening modeli Keras za pomocą TensorFlow Cloud

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub Pobierz notatnik

Wstęp

TensorFlow Chmura to pakiet Pythona, który udostępnia API dla płynne przejście od lokalnego debugowania do rozproszonego szkolenia w Google Cloud. Upraszcza proces uczenia modeli TensorFlow w chmurze do pojedynczego, prostego wywołania funkcji, wymagającego minimalnej konfiguracji i braku zmian w modelu. TensorFlow Cloud obsługuje zadania specyficzne dla chmury, takie jak automatyczne tworzenie instancji maszyn wirtualnych i strategii dystrybucji modeli. Ten przewodnik pokaże, jak łączyć się z Google Cloud za pośrednictwem TensorFlow Cloud oraz szeroki zakres funkcji dostępnych w TensorFlow Cloud. Zaczniemy od najprostszego przypadku użycia.

Ustawiać

Zaczniemy od zainstalowania chmury TensorFlow i zaimportowania pakietów, których będziemy potrzebować w tym przewodniku.

pip install -q tensorflow_cloud
import tensorflow as tf
import tensorflow_cloud as tfc

from tensorflow import keras
from tensorflow.keras import layers
2021-07-27 22:07:16.348453: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

Przegląd API: pierwszy kompleksowy przykład

Zacznijmy od skryptu szkoleniowego modelu Keras, takiego jak następujący CNN:

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

model = keras.Sequential(
    [
        keras.Input(shape=(28, 28)),
        # Use a Rescaling layer to make sure input values are in the [0, 1] range.
        layers.experimental.preprocessing.Rescaling(1.0 / 255),
        # The original images have shape (28, 28), so we reshape them to (28, 28, 1)
        layers.Reshape(target_shape=(28, 28, 1)),
        # Follow-up with a classic small convnet
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.Flatten(),
        layers.Dense(128, activation="relu"),
        layers.Dense(10),
    ]
)

model.compile(
    optimizer=keras.optimizers.Adam(),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=keras.metrics.SparseCategoricalAccuracy(),
)

model.fit(x_train, y_train, epochs=20, batch_size=128, validation_split=0.1)

Trenować ten model na Google Cloud musimy tylko dodać wywołanie run() na początku skryptu, przed przywozem:

tfc.run()

Nie musisz martwić się zadaniami związanymi z chmurą, takimi jak tworzenie instancji maszyn wirtualnych i strategii dystrybucji, korzystając z TensorFlow Cloud. Interfejs API zawiera inteligentne wartości domyślne dla wszystkich parametrów — wszystko można konfigurować, ale wiele modeli może polegać na tych wartościach domyślnych.

Po zawołaniu run() , TensorFlow Chmura będzie:

  • Przygotuj swój skrypt Pythona lub dystrybucję notatnika.
  • Przekonwertuj go na obraz platformy Docker z wymaganymi zależnościami.
  • Uruchom zadanie szkoleniowe na maszynie wirtualnej z procesorem graficznym GCP.
  • Przesyłaj strumieniowo odpowiednie dzienniki i informacje o zadaniach.

Domyślna konfiguracja maszyny wirtualnej to 1 główny i 0 pracowników z 8 rdzeniami CPU i 1 GPU Tesla T4.

Konfiguracja Google Cloud

Aby ułatwić właściwe ścieżki szkolenia w chmurze, będziesz musiał przeprowadzić pewną konfigurację po raz pierwszy. Jeśli jesteś nowym użytkownikiem Google Cloud, musisz wykonać kilka wstępnych czynności:

  1. Utwórz projekt GCP;
  2. Włącz usługi AI Platform;
  3. Załóż Konto Serwisowe;
  4. Pobierz klucz autoryzacyjny;
  5. Utwórz zasobnik Cloud Storage.

Szczegółowe instrukcje pierwszej konfiguracji można znaleźć w TensorFlow chmurze README oraz dodatkowy przykład konfiguracja jest pokazany na blogu TensorFlow .

Typowe przepływy pracy i przechowywanie w chmurze

W większości przypadków będziesz chciał odzyskać swój model po przeszkoleniu w Google Cloud. W tym celu kluczowe jest przekierowanie zapisywania i ładowania do Cloud Storage podczas zdalnego szkolenia. Możemy skierować TensorFlow Cloud do naszego zasobnika Cloud Storage w celu wykonania różnych zadań. Zasobnik magazynu może służyć do zapisywania i ładowania dużych treningowych zestawów danych, przechowywania dzienników wywołań zwrotnych lub wag modeli oraz zapisywania trenowanych plików modeli. Aby rozpocząć, niech configure fit() , aby zapisać model do Cloud Storage i skonfigurować TensorBoard monitorowania w celu śledzenia postępów w treningu.

def create_model():
    model = keras.Sequential(
        [
            keras.Input(shape=(28, 28)),
            layers.experimental.preprocessing.Rescaling(1.0 / 255),
            layers.Reshape(target_shape=(28, 28, 1)),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.Flatten(),
            layers.Dense(128, activation="relu"),
            layers.Dense(10),
        ]
    )

    model.compile(
        optimizer=keras.optimizers.Adam(),
        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        metrics=keras.metrics.SparseCategoricalAccuracy(),
    )
    return model

Zapiszmy logi TensorBoard i punkty kontrolne modelu wygenerowane podczas szkolenia w naszym zasobniku do przechowywania w chmurze.

import datetime
import os

# Note: Please change the gcp_bucket to your bucket name.
gcp_bucket = "keras-examples"

checkpoint_path = os.path.join("gs://", gcp_bucket, "mnist_example", "save_at_{epoch}")

tensorboard_path = os.path.join(  # Timestamp included to enable timeseries graphs
    "gs://", gcp_bucket, "logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
)

callbacks = [
    # TensorBoard will store logs for each epoch and graph performance for us.
    keras.callbacks.TensorBoard(log_dir=tensorboard_path, histogram_freq=1),
    # ModelCheckpoint will save models after each epoch for retrieval later.
    keras.callbacks.ModelCheckpoint(checkpoint_path),
    # EarlyStopping will terminate training when val_loss ceases to improve.
    keras.callbacks.EarlyStopping(monitor="val_loss", patience=3),
]

model = create_model()
2021-07-27 22:07:18.825259: I tensorflow/core/profiler/lib/profiler_session.cc:126] Profiler session initializing.
2021-07-27 22:07:18.825306: I tensorflow/core/profiler/lib/profiler_session.cc:141] Profiler session started.
2021-07-27 22:07:18.826514: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-07-27 22:07:19.524654: I tensorflow/core/profiler/internal/gpu/cupti_tracer.cc:1611] Profiler found 1 GPUs
2021-07-27 22:07:19.569799: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcupti.so.11.2
2021-07-27 22:07:19.574795: I tensorflow/core/profiler/lib/profiler_session.cc:159] Profiler session tear down.
2021-07-27 22:07:19.574958: I tensorflow/core/profiler/internal/gpu/cupti_tracer.cc:1743] CUPTI activity buffer flushed
2021-07-27 22:07:19.590994: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.592061: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-27 22:07:19.592100: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-27 22:07:19.595897: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-07-27 22:07:19.595991: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-07-27 22:07:19.597230: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-07-27 22:07:19.597581: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-07-27 22:07:19.598756: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-07-27 22:07:19.599746: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-07-27 22:07:19.599930: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-07-27 22:07:19.600043: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.601088: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.602037: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-27 22:07:19.602416: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-07-27 22:07:19.603033: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.604024: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-27 22:07:19.604096: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.605089: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.606005: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-27 22:07:19.606052: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-27 22:07:20.242028: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-07-27 22:07:20.242067: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-07-27 22:07:20.242076: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-07-27 22:07:20.242317: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:20.243478: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:20.244412: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:20.245277: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.

Tutaj załadujemy nasze dane bezpośrednio z Keras. Ogólnie najlepszym rozwiązaniem jest przechowywanie zestawu danych w zasobniku Cloud Storage, jednak TensorFlow Cloud może również pomieścić zestawy danych przechowywane lokalnie. Zostało to omówione w sekcji Wiele plików tego przewodnika.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

TensorFlow Chmura API zapewnia remote() funkcji, aby ustalić, czy kod jest wykonywany lokalnie lub w chmurze. Pozwala to na osobnej nazwy fit() parametry dla realizacji lokalnej i zdalnej, a także zapewnia środki do łatwego debugowania bez przeciążania komputerze lokalnym.

if tfc.remote():
    epochs = 100
    callbacks = callbacks
    batch_size = 128
else:
    epochs = 5
    batch_size = 64
    callbacks = None

model.fit(x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size)
2021-07-27 22:07:21.458608: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-07-27 22:07:21.459072: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000170000 Hz
Epoch 1/5
2021-07-27 22:07:21.885085: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-07-27 22:07:23.986122: I tensorflow/stream_executor/cuda/cuda_dnn.cc:359] Loaded cuDNN version 8100
2021-07-27 22:07:29.307903: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-07-27 22:07:29.684317: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
938/938 [==============================] - 12s 3ms/step - loss: 0.2065 - sparse_categorical_accuracy: 0.9374
Epoch 2/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0577 - sparse_categorical_accuracy: 0.9822
Epoch 3/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0415 - sparse_categorical_accuracy: 0.9868
Epoch 4/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0332 - sparse_categorical_accuracy: 0.9893
Epoch 5/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0275 - sparse_categorical_accuracy: 0.9915
<tensorflow.python.keras.callbacks.History at 0x7f7b0c66a390>

Zapiszmy model w GCS po zakończeniu szkolenia.

save_path = os.path.join("gs://", gcp_bucket, "mnist_example")

if tfc.remote():
    model.save(save_path)

Możemy również użyć tego zasobnika do przechowywania do tworzenia obrazów platformy Docker zamiast lokalnej instancji platformy Docker. Do tego wystarczy dodać wiadro do docker_image_bucket_name parametru.

# docs_infra: no_execute
tfc.run(docker_image_bucket_name=gcp_bucket)

Po wytrenowaniu modelu możemy załadować zapisany model i przeglądać nasze logi TensorBoard w celu monitorowania wydajności.

# docs_infra: no_execute
model = keras.models.load_model(save_path)
#docs_infra: no_execute
tensorboard dev upload --logdir "gs://keras-examples-jonah/logs/fit" --name "Guide MNIST"

Projekty na dużą skalę

W wielu przypadkach projekt zawierający model Keras może obejmować więcej niż jeden skrypt Pythona lub może obejmować dane zewnętrzne lub określone zależności. TensorFlow Cloud jest w pełni elastyczny do wdrażania na dużą skalę i zapewnia szereg inteligentnych funkcji, które wspomagają Twoje projekty.

Punkty wejścia: obsługa skryptów Pythona i notatników Jupyter

Rozmowa z run() API nie zawsze będą zawarte wewnątrz tego samego skryptu Pythona jako kodzie modelu szkolenia. W tym celu zapewniamy entry_point parametr. entry_point parametr może być używany do określenia skrypt Pythona lub notebooka, w którym wasze życie kod szkolenia modelu. Dzwoniąc run() z tego samego skryptu jako modelu, użyj entry_point domyślną None .

pip zależności

W przypadku połączeń projektu na dodatkowych pip zależności, to jest możliwe, aby określić dodatkowe wymagane biblioteki przez włączenie requirements.txt pliku. W tym pliku po prostu umieść listę wszystkich wymaganych zależności, a TensorFlow Cloud zajmie się integracją ich z Twoją kompilacją chmury.

Notatniki Pythona

TensorFlow Cloud można również uruchomić z notatników Pythona. Dodatkowo swoją określony entry_point może być notebooka w razie potrzeby. Istnieją dwie kluczowe różnice, o których należy pamiętać między TensorFlow Cloud na notebookach a skryptami:

  • Dzwoniąc run() od wewnątrz notebooka, wiadro Cloud Storage musi być określona na budowę i przechowywania Docker obraz.
  • Uwierzytelnianie GCloud odbywa się całkowicie za pomocą klucza uwierzytelniania, bez specyfikacji projektu. Przykładowy przepływ pracy przy użyciu TensorFlow Cloud z notatnika znajduje się w sekcji „Łączenie wszystkiego” tego przewodnika.

Projekty wieloplikowe

Jeśli model zależy od dodatkowych plików, wystarczy upewnić się, że te pliki znajdują się w tym samym katalogu (lub podkatalogu) określonego punktu wejścia. Każdy plik, który jest przechowywany w tym samym katalogu co określony entry_point będą zawarte w obrazie Docker, jak również wszystkich plików przechowywanych w podkatalogów przylegających do entry_point . Odnosi się to również do zależności mogą być potrzebne, które nie mogą być nabyte przez pip

Na przykład niestandardowego punktu wejścia i projektu wielu plików z dodatkowymi zależnościami pip, spojrzeć na ten przykład wielu plików na TensorFlow chmurze repozytorium . Dla zwięzłości, po prostu to na przykładzie run() wywołanie:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    entry_point="train_model.py",
    requirements="requirements.txt"
)

Konfiguracja maszyn i szkolenia rozproszone

Trenowanie modelu może wymagać wielu różnych zasobów, w zależności od rozmiaru modelu lub zestawu danych. Przy rozliczaniu konfiguracjach z wieloma procesorami graficznymi, staje się krytyczna wybrać dopasowany strategię dystrybucji . Tutaj przedstawiamy kilka możliwych konfiguracji:

Dystrybucja dla wielu pracowników

Tutaj możemy użyć COMMON_MACHINE_CONFIGS wyznaczyć główne CPU 1 i 4 pracownik GPU.

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X']
)

Domyślnie TensorFlow Chmura wybiera najlepszą strategię dystrybucyjną dla konfiguracji urządzenia za pomocą prostego wzoru z wykorzystaniem chief_config , worker_config i worker_count parametry przewidziane.

Dystrybucja TPU

Wytrenujmy ten sam model na TPU, jak pokazano:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS["CPU"],
    worker_count=1,
    worker_config=tfc.COMMON_MACHINE_CONFIGS["TPU"]
)

Niestandardowa strategia dystrybucji

Aby określić strategię dystrybucji niestandardowego formatowania kodu normalnie tak jak według rozproszonej podręczniku szkoleniowym i ustawić distribution_strategy do None . Poniżej określimy własną strategię dystrybucji dla tego samego modelu MNIST.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
  model = create_model()

if tfc.remote():
    epochs = 100
    batch_size = 128
else:
    epochs = 10
    batch_size = 64
    callbacks = None

model.fit(
    x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size
)

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X'],
    distribution_strategy=None
)

Niestandardowe obrazy Dockera

Domyślnie TensorFlow Chmura używa obraz bazowy Docker dostarczonego przez Google i odpowiadającą aktualnej wersji TensorFlow. W razie potrzeby można jednak również określić niestandardowy obraz platformy Docker, aby pasował do wymagań kompilacji. W tym przykładzie określimy obraz Docker ze starszej wersji TensorFlow:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    base_docker_image="tensorflow/tensorflow:2.1.0-gpu"
)

Dodatkowe metryki

Przydatne może być oznaczanie zadań Cloud za pomocą określonych etykiet lub przesyłanie strumieniowe dzienników modelu podczas szkolenia w chmurze. Dobrą praktyką jest utrzymywanie prawidłowego etykietowania wszystkich zadań w chmurze w celu prowadzenia dokumentacji. W tym celu, run() akceptuje słownika etykiet aż do 64 par klucz-wartość, która jest widoczna z logów kompilacji chmurze. Dzienniki, takie jak wydajność epoki i model oszczędności wewnętrznych można uzyskać za pomocą linku podanego przez wykonanie tfc.run lub wydrukowany na lokalnym terminalu używając stream_logs flagę.

job_labels = {"job": "mnist-example", "team": "keras-io", "user": "jonah"}

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    job_labels=job_labels,
    stream_logs=True
)

Kładąc wszystko razem

Dla pogłębionej Colab który wykorzystuje wiele funkcji opisanych w niniejszej instrukcji, podążać tym przykładzie trenować state-of-the-art model rozpoznać ras psów ze zdjęć za pomocą ekstrakcji funkcji.