Przewodnik po korzystaniu

Interfejs API tfc.run umożliwia trenowanie modeli na dużą skalę w GCP.

API tfc.run można używać na cztery różne sposoby. Jest to definiowane na podstawie miejsca uruchomienia interfejsu API (skrypt Pythona lub notatnik Pythona) i parametru entry_point :

  • Plik Pythona jako entry_point .
  • Plik notatnika jako entry_point .
  • run w skrypcie Pythona zawierającym model tf.keras .
  • run w skrypcie notatnika zawierającym model tf.keras . Najpopularniejszym sposobem jest użycie run w notatniku.

entry_point to (ścieżka do) skryptu Pythona lub pliku notatnika albo None . Jeśli None , cały bieżący plik zostanie wysłany do Google Cloud.

Używanie pliku Pythona jako entry_point .

Jeśli masz model tf.keras w pliku Pythona ( mnist_example.py ), możesz napisać następujący prosty skrypt ( scale_mnist.py ), aby przeskalować model w GCP.

import tensorflow_cloud as tfc
tfc.run(entry_point='mnist_example.py')

Należy pamiętać, że wszystkie pliki w tym samym drzewie katalogów co entry_point zostaną spakowane w utworzonym obrazie okna dokowanego wraz z plikiem entry_point . Zaleca się utworzenie nowego katalogu do przechowywania każdego projektu w chmurze, który będzie zawierał niezbędne pliki i nic więcej, aby zoptymalizować czas tworzenia obrazu.

Używanie pliku notatnika jako entry_point .

Jeśli masz model tf.keras w pliku notatnika ( mnist_example.ipynb ), możesz napisać następujący prosty skrypt ( scale_mnist.py ), aby przeskalować model w GCP.

import tensorflow_cloud as tfc
tfc.run(entry_point='mnist_example.ipynb')

Należy pamiętać, że wszystkie pliki w tym samym drzewie katalogów co entry_point zostaną spakowane w utworzonym obrazie okna dokowanego wraz z plikiem entry_point . Podobnie jak w przypadku powyższego entry_point skryptu Pythona, zalecamy utworzenie nowego katalogu do przechowywania każdego projektu w chmurze, który będzie zawierał niezbędne pliki i nic więcej, aby zoptymalizować czas tworzenia obrazu.

Używanie run w skrypcie Pythona, który zawiera model tf.keras .

Możesz użyć run API z poziomu pliku Pythona, który zawiera model tf.keras ( mnist_scale.py ). W tym przypadku entry_point powinien mieć None . run API można wywołać w dowolnym miejscu, a cały plik zostanie wykonany zdalnie. Na końcu można wywołać interfejs API, aby uruchomić skrypt lokalnie w celu debugowania (prawdopodobnie z mniejszą liczbą epok i innymi flagami).

import tensorflow_datasets as tfds
import tensorflow as tf
import tensorflow_cloud as tfc

tfc.run(
    entry_point=None,
    distribution_strategy='auto',
    requirements_txt='requirements.txt',
    chief_config=tfc.MachineConfig(
            cpu_cores=8,
            memory=30,
            accelerator_type=tfc.AcceleratorType.NVIDIA_TESLA_T4,
            accelerator_count=2),
    worker_count=0)

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']

num_train_examples = info.splits['train'].num_examples
num_test_examples = info.splits['test'].num_examples

BUFFER_SIZE = 10000
BATCH_SIZE = 64

def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255
    return image, label

train_dataset = mnist_train.map(scale).cache()
train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(
        28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(loss='sparse_categorical_crossentropy',
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])
model.fit(train_dataset, epochs=12)

Należy pamiętać, że wszystkie pliki w tym samym drzewie katalogów, w którym znajduje się skrypt Pythona, zostaną spakowane w utworzonym obrazie okna dokowanego wraz z plikiem Pythona. Zaleca się utworzenie nowego katalogu do przechowywania każdego projektu w chmurze, który będzie zawierał niezbędne pliki i nic więcej, aby zoptymalizować czas tworzenia obrazu.

Użycie run w skrypcie notatnika, który zawiera model tf.keras .

Obraz Colaba

W tym przypadku entry_point powinien mieć None i należy określić docker_config.image_build_bucket , aby mieć pewność, że kompilacja będzie mogła zostać zapisana i opublikowana.

Co się stanie, gdy zadzwonisz run ?

Wywołanie API wykona następujące czynności:

  1. Przygotowanie jednostek kodu, takich jak skrypt/notatnik Keras, chmura i dystrybucja .
  2. Konwersja tej jednostki dystrybucyjnej na kontener dokowany z wymaganymi zależnościami.
  3. Wdróż ten kontener na dużą skalę i trenuj, korzystając ze strategii dystrybucji TensorFlow.
  4. Przesyłaj strumieniowo logi i monitoruj je na hostowanym TensorBoard, zarządzaj pamięcią w punktach kontrolnych.

Domyślnie lokalny demon Dockera służący do tworzenia i publikowania obrazów Dockera w rejestrze kontenerów Google. Obrazy są publikowane na gcr.io/your-gcp-project-id . Jeśli określisz docker_config.image_build_bucket , użyjemy kompilacji Google Cloud do tworzenia i publikowania obrazów dokerów.

Platforma Google AI służy do wdrażania obrazów Dockera w Google Cloud.